--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepAudInStream.cpp	Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,3089 @@
+// Copyright (c) 2002-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:
+// This file contains an example Test step implementation 
+// This demonstrates the various functions provided
+// by the CTestStep base class which are available within
+// a test step 
+// 
+//
+
+// EPOC includes
+#include <e32base.h>
+#include <e32test.h>
+#include <e32keys.h>
+#include <c32comm.h>
+#include <f32file.h>
+#include <etel.h>
+#include <etelmm.h>
+
+// Test system includes
+#include <testframework.h>
+
+// Specific includes for this test suite
+#include "TestStepUnitMMFAudClient.h"
+#include "TestSuiteUnitMMFAudClient.h"
+
+// Specific includes for these test steps
+#include "TestStepAudInStream.h"
+#include "mmfclientaudioinputstream.h"
+#include <mda/common/audio.h>
+
+//
+// --------------------------------------------
+//
+// base class for some audio Input stream tests
+//_LIT(KStreamRawFile,"c:\\mm\\mmf\\testfiles\\aclnt\\test.raw");	// EABI warning removal
+//_LIT(KStreamIMADFile,"c:\\mm\\mmf\\testfiles\\aclnt\\test.raw");	// EABI warning removal
+_LIT(KRecordStreamRawFile,"c:\\mm\\mmf\\testfiles\\aclnt\\streamrecorded.raw");
+
+const TInt KMicroSecsInOneSec = 1000000;
+//const TInt KBitsPerSample = 16;	// EABI warning removal
+const TInt KBytesPerSample = 2;
+const TInt KSampleRate = 8000;
+
+// constant table of parameters for tests
+const TStreamInConvParameters KTestParameters[] =
+{	
+	// straight encode test
+	
+	{ _S("MM-MMF-ACLNT-U-0740-CP"), KMMFFourCCCodePCMU8},
+	{ _S("MM-MMF-ACLNT-U-0741-CP"), KMMFFourCCCodePCM16},
+	{ _S("MM-MMF-ACLNT-U-0742-CP"), KMMFFourCCCodeALAW},
+	{ _S("MM-MMF-ACLNT-U-0743-CP"), KMMFFourCCCodeMuLAW},
+	{ _S("MM-MMF-ACLNT-U-0744-CP"), KMMFFourCCCodeIMAD},
+	{ _S("MM-MMF-ACLNT-U-0745-CP"), KMMFFourCCCodePCM16B},
+	{ _S("MM-MMF-ACLNT-U-0746-CP"), KMMFFourCCCodeGSM610}
+};
+
+CTestStepAudInStream* CTestStepAudInStream::NewL()
+	{
+	CTestStepAudInStream* s = new(ELeave) CTestStepAudInStream();
+	CleanupStack::PushL(s);
+	s->ConstructL();
+	CleanupStack::Pop();
+	return s;
+	}
+
+CTestStepAudInStream::CTestStepAudInStream() : iError(KErrNone)
+	{
+	iTestStepName = _L("MM-MMF-ACLNT-U-0999-CP");
+	}
+
+void CTestStepAudInStream::ConstructL()
+	{
+	// reset the buffer
+	for(TInt i=0; i<KRecNumBuffer; i++)
+		{
+		iBufferList[i] = KNullDesC8;
+		}
+	iStartBuf=iEndBuf=0;
+	}
+
+CTestStepAudInStream::~CTestStepAudInStream()
+	{
+	}
+
+void CTestStepAudInStream::MaiscOpenComplete(TInt aError)
+	{
+	iError = aError;
+	CActiveScheduler::Stop();
+	}
+
+void CTestStepAudInStream::MaiscRecordComplete(TInt aError)
+	{
+	iError = aError;
+	
+	iWriteBufferActive->Cancel();
+	TInt filePosition=0;
+	iFile.Seek(ESeekStart, filePosition);
+	iFile.Close();
+	CActiveScheduler::Stop();
+	}
+
+void CTestStepAudInStream::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)
+	{
+	iError = aError;
+	if(aError != KErrNone)
+		{
+		return;   
+		}
+	// Assume aBuffer == iBufferList[iEndBuf]
+
+	// Increment iEndBuf
+	if(iEndBuf==KRecNumBuffer-1)
+		iEndBuf = 0;
+	else
+		iEndBuf++;
+
+	// Starting writing out the buffers if we're not already
+	if(!iWriteBufferActive->IsActive())
+		iWriteBufferActive->Write(iBufferList[iStartBuf]);
+	}
+
+void CTestStepAudInStream::StartReadL()
+	{
+	// Issue reads on all available buffers
+	for (TInt ii=0; ii<KRecNumBuffer; ii++)
+	    {
+		iAudInStream->ReadL(iBufferList[ii]);
+	    }
+	}
+
+CTestStepAudInStream::CWriteBufferActive::CWriteBufferActive() : CActive(0)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+CTestStepAudInStream::CWriteBufferActive::~CWriteBufferActive()
+	{
+	Cancel();
+	}
+
+void CTestStepAudInStream::CWriteBufferActive::RunL()
+	{
+	//ASSERT it wrote OK
+	iParent->ProcessDataL();
+	}
+
+void CTestStepAudInStream::CWriteBufferActive::DoCancel()
+	{
+	// do nothing
+	}
+
+void CTestStepAudInStream::CWriteBufferActive::Write(const TDesC8& aBuffer)
+	{
+	iParent->iFile.Write(aBuffer, iStatus);      // read the 1st data trunk
+	SetActive();		
+	}
+
+
+void CTestStepAudInStream::ProcessDataL()
+	{
+	// Set the next buffer to handle
+	iBufferList[iStartBuf] = KNullDesC8; // done with that one
+	// Issue another read to input stream
+	iAudInStream->ReadL(iBufferList[iStartBuf]);
+	
+	// Increment iStartBuf
+	if(iStartBuf==KRecNumBuffer-1)
+		iStartBuf=0;
+	else
+		iStartBuf++;
+	
+	if (iBufferList[iStartBuf] != KNullDesC8)
+		{
+		// Still more to write
+		iWriteBufferActive->Write(iBufferList[iStartBuf]);
+		}
+	// else just wait for more recorded data to come through
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStream::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// create the active object
+	iWriteBufferActive = new(ELeave) CWriteBufferActive();
+	iWriteBufferActive->iParent = this;
+	iFs.Connect();
+
+	TRAPD(err, iAudInStream = CMMFMdaAudioInputStream::NewL(*this) );
+	
+
+	if (err != KErrNone ||
+		iAudInStream == NULL )
+		return EInconclusive;
+	 	 
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStream::DoTestStepPostambleL(void)
+	{
+	iFs.Close();
+
+	delete iAudInStream;
+	iAudInStream = NULL;
+	delete iWriteBufferActive;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStream::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+	TInt err = KErrNone;
+
+	if (iError != KErrNone )
+		 return EFail;
+
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		return EFail;
+
+	StartReadL();
+	CActiveScheduler::Start();
+
+	iFile.Close();
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+// --------------------------------------------
+
+/**
+ *
+ * Static constructor for CTestStepAudInStreamNew.
+ *
+ *
+ * @return	"CTestStepAudInStreamNew*"
+ *			The constructed CTestStepAudInStreamNew
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamNew* CTestStepAudInStreamNew::NewL()
+	{
+	CTestStepAudInStreamNew* self = new(ELeave) CTestStepAudInStreamNew;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamNew::CTestStepAudInStreamNew()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0700-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamNew::~CTestStepAudInStreamNew()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamNew::MaiscOpenComplete(TInt /*aError*/)
+	{
+	}
+void CTestStepAudInStreamNew::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void CTestStepAudInStreamNew::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamNew::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamNew::DoTestStepPostambleL(void)
+	{
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamNew::DoTestStepL()
+	{
+	__MM_HEAP_MARK;
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0700-CP"));
+	INFO_PRINTF1(_L("this test is initialising an Audio Input Stream Utility Class"));
+
+	iAudInStream = CMMFMdaAudioInputStream::NewL(*this);
+
+	if ( iAudInStream == NULL )
+		 iTestStepResult = EFail;
+	else 
+		 iTestStepResult = EPass;
+
+	delete iAudInStream;
+	iAudInStream = NULL;
+	__MM_HEAP_MARKEND;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamSetProp.
+ *
+ *
+ * @return	"CTestStepAudInStreamSetProp*"
+ *			The constructed CTestStepAudInStreamSetProp
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetProp* CTestStepAudInStreamSetProp::NewL()
+	{
+	CTestStepAudInStreamSetProp* self = new(ELeave) CTestStepAudInStreamSetProp;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetProp::CTestStepAudInStreamSetProp()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0701-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetProp::~CTestStepAudInStreamSetProp()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamSetProp::MaiscOpenComplete(TInt aError)
+	{
+	iError = aError;
+	CActiveScheduler::Stop();
+	}
+void CTestStepAudInStreamSetProp::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)
+	{
+	iError = aError;
+	}
+void CTestStepAudInStreamSetProp::MaiscRecordComplete(TInt aError)
+	{
+	iError = aError;
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamSetProp::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	 // Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0701-CP"));
+	INFO_PRINTF1(_L("this test is setting the audio properties of an Audio Input Stream Utility Class"));
+
+	iAudInStream = CMMFMdaAudioInputStream::NewL(*this);
+	if (iAudInStream == NULL)
+		return EInconclusive;
+	 
+	iAudInStream->Open(NULL);
+		CActiveScheduler::Start();
+	
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamSetProp::DoTestStepPostambleL(void)
+	{
+	delete iAudInStream;
+	iAudInStream = NULL;
+	//CActiveScheduler::Stop();
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamSetProp::DoTestStepL()
+	{
+	//TMdaAudioDataSettings settings;
+		//	settings.Query();
+		//	settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; // ESampleRateAnyInRange
+		//	settings.iChannels = TMdaAudioDataSettings::EChannelsMono;
+		//	settings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting;
+		//	settings.iVolume = 0;
+		
+	
+	
+	iTestStepResult = EPass;
+	TInt err = KErrNone;
+
+	// test 1
+	TRAP(err, iAudInStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate8000Hz,TMdaAudioDataSettings::EChannelsMono) );
+
+	if (!(err == KErrNone || 
+		  err == KErrNotSupported) )
+		 return EFail;
+
+	// test2
+	TRAP(err, iAudInStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate44100Hz,TMdaAudioDataSettings::EChannelsStereo) );
+
+	if (!(err == KErrNone || 
+		  err == KErrNotSupported) )
+		 return EFail;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamOpen.
+ *
+ *
+ * @return	"CTestStepAudInStreamOpen*"
+ *			The constructed CTestStepAudInStreamOpen
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamOpen* CTestStepAudInStreamOpen::NewL()
+	{
+	CTestStepAudInStreamOpen* self = new(ELeave) CTestStepAudInStreamOpen;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamOpen::CTestStepAudInStreamOpen()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0702-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamOpen::~CTestStepAudInStreamOpen()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamOpen::DoTestStepPreambleL(void)
+	{
+	enum TVerdict verdict;
+	// this installs the scheduler and NEWLs the CMMFMdaAudioInputStream
+	verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0702-CP"));
+	INFO_PRINTF1(_L("this test is openning an Audio Input Stream Utility Class"));
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamOpen::DoTestStepPostambleL(void)
+	{
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamOpen::DoTestStepL()
+	{
+	TMdaAudioDataSettings settings;
+	settings.Query();
+	settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; // ESampleRateAnyInRange
+	settings.iChannels = TMdaAudioDataSettings::EChannelsStereo;
+	settings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting;
+	settings.iVolume = 0;
+	
+	//Test Open with audio settings
+	iAudInStream->Open(&settings);
+	CActiveScheduler::Start();
+
+	TBool stopped = EFalse;
+	TInt err = KErrNone;
+	err = GetAudInStreamStopped(iAudInStream, stopped);
+	
+	if (iError != KErrNone || err != KErrNone || !stopped )
+		{
+		INFO_PRINTF1(_L("Open with audio settings failed"));
+		return EFail;
+		}
+	
+	//Test Open with NULL
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+
+	stopped = EFalse;
+	err = GetAudInStreamStopped(iAudInStream, stopped);
+	
+	if (iError != KErrNone || err != KErrNone || !stopped )
+		{
+		INFO_PRINTF1(_L("Open without audio settings failed"));
+		return EFail;
+		}
+	else
+		{
+		return EPass;
+		}
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamSetGain.
+ *
+ *
+ * @return	"CTestStepAudInStreamSetGain*"
+ *			The constructed CTestStepAudInStreamSetGain
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetGain* CTestStepAudInStreamSetGain::NewL()
+	{
+	CTestStepAudInStreamSetGain* self = new(ELeave) CTestStepAudInStreamSetGain;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetGain::CTestStepAudInStreamSetGain()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0703-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetGain::~CTestStepAudInStreamSetGain()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamSetGain::MaiscOpenComplete(TInt /*aError*/)
+	{
+	}
+void CTestStepAudInStreamSetGain::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void CTestStepAudInStreamSetGain::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamSetGain::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0703-CP"));
+	INFO_PRINTF1(_L("this test is setting/getting the Gain of an Audio Input Stream Utility Class"));
+
+	iAudInStream = CMMFMdaAudioInputStream::NewL(*this);
+
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamSetGain::DoTestStepPostambleL(void)
+	{
+	delete iAudInStream;
+	iAudInStream = NULL;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamSetGain::DoTestStepL()
+	{
+	TInt gain = iAudInStream->MaxGain()/2;
+	if (gain < 0)
+		return EFail;
+	//set the volume
+	iAudInStream->SetGain(gain);
+
+	//get the volume
+	TInt rgain = iAudInStream->Gain();
+	if (gain != rgain ) 
+		 return EFail;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamSetPrior.
+ *
+ *
+ * @return	"CTestStepAudInStreamSetPrior*"
+ *			The constructed CTestStepAudInStreamSetPrior
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetPrior* CTestStepAudInStreamSetPrior::NewL()
+	{
+	CTestStepAudInStreamSetPrior* self = new(ELeave) CTestStepAudInStreamSetPrior;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetPrior::CTestStepAudInStreamSetPrior()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0708-HP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetPrior::~CTestStepAudInStreamSetPrior()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamSetPrior::MaiscOpenComplete(TInt /*aError*/)
+	{
+	}
+void CTestStepAudInStreamSetPrior::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void CTestStepAudInStreamSetPrior::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamSetPrior::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0708-HP"));
+	INFO_PRINTF1(_L("this test is setting the audio priorities of an Audio Input Stream Utility Class"));
+
+	iAudInStream = CMMFMdaAudioInputStream::NewL(*this);
+
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamSetPrior::DoTestStepPostambleL(void)
+	{
+	delete iAudInStream;
+	iAudInStream = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamSetPrior::DoTestStepL()
+	{
+//	TInt err = KErrNone;
+
+	// test 1
+	iAudInStream->SetPriority(EMdaPriorityMin, EMdaPriorityPreferenceTime);
+
+/*	TMMFPrioritySettings prior;
+	err = GetAudInStreamPrioritySettings(iAudInStream, prior);
+	if ( err != KErrNone || 
+		 prior.iPriority != EMdaPriorityMin ||
+		 prior.iPref != EMdaPriorityPreferenceTime)
+		 return EFail;
+*/
+	// test2
+	iAudInStream->SetPriority(EMdaPriorityMax, EMdaPriorityPreferenceQuality);
+
+/*	err = GetAudInStreamPrioritySettings(iAudInStream, prior);
+	if ( err != KErrNone || 
+		 prior.iPriority != EMdaPriorityMax ||
+		 prior.iPref != EMdaPriorityPreferenceQuality)
+		 return EFail;
+*/
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamSetBalance.
+ *
+ *
+ * @return	"CTestStepAudInStreamSetBalance*"
+ *			The constructed CTestStepAudInStreamSetBalance
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetBalance* CTestStepAudInStreamSetBalance::NewL()
+	{
+	CTestStepAudInStreamSetBalance* self = new(ELeave) CTestStepAudInStreamSetBalance;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetBalance::CTestStepAudInStreamSetBalance()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0706-HP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamSetBalance::~CTestStepAudInStreamSetBalance()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamSetBalance::MaiscOpenComplete(TInt /*aError*/)
+	{
+	}
+void CTestStepAudInStreamSetBalance::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void CTestStepAudInStreamSetBalance::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamSetBalance::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	 TInt err = KErrNone;
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0706-HP"));
+	INFO_PRINTF1(_L("this test is setting and getting the balance of an Audio Input Stream Utility Class"));
+
+	TRAP(err, iAudInStream = CMMFMdaAudioInputStream::NewL(*this) );
+
+	if (err != KErrNone ||
+		iAudInStream == NULL )
+		return EInconclusive;
+
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamSetBalance::DoTestStepPostambleL(void)
+	{
+	delete iAudInStream;
+	iAudInStream = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamSetBalance::DoTestStepL()
+	{
+	TInt bal = 0;
+
+	TRAPD(err, iAudInStream->SetBalanceL()); // default KMMFBalanceCenter
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	//get the balance
+	TRAP(err, bal = iAudInStream->GetBalanceL());
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	if (bal != KMMFBalanceCenter )
+		return EFail;
+
+	TRAP(err, iAudInStream->SetBalanceL(KMMFBalanceMaxRight));
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	//get the balance
+	TRAP(err, bal = iAudInStream->GetBalanceL());
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	if (bal != KMMFBalanceMaxRight )
+		return EFail;
+
+	TRAP(err, iAudInStream->SetBalanceL(KMMFBalanceMaxLeft));
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	//get the balance
+	TRAP(err, bal = iAudInStream->GetBalanceL());
+	if (err != KErrNone)
+		return EFail; // we expect this _will_ be supported for Typhoon
+
+	if (bal != KMMFBalanceMaxLeft )
+		return EFail;
+
+	// In of bounds
+	/*
+	iAudInStream->SetBalance(KMMFBalanceMaxLeft+10);
+	//check condition
+	*/
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamRead.
+ *
+ *
+ * @return	"CTestStepAudInStreamRead*"
+ *			The constructed CTestStepAudInStreamRead
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamRead* CTestStepAudInStreamRead::NewL(TUint aTestIndex)
+	{
+	CTestStepAudInStreamRead* self = new(ELeave) CTestStepAudInStreamRead(aTestIndex);
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamRead::CTestStepAudInStreamRead(TUint aTestIndex)
+	{
+	iTestStepResult = EPass;
+	// store a pointer to the test parameters
+	iTestParameters = &(KTestParameters[aTestIndex]);
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = iTestParameters->iTestName;
+	iHeapSize = 131072;		//	~128k
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamRead::~CTestStepAudInStreamRead()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamRead::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	// this installs the scheduler, and NEWLs the input stream object
+	 verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("this test is reading data from an Audio Input Stream Utility Class. ReadL()"));
+
+	TInt err = KErrNone;
+	TRAP(err, iAudInStream->SetDataTypeL(iTestParameters->iEncoding));
+
+	if (err != KErrNone)
+		 return EInconclusive;
+
+	iAudInStream->Open(NULL);
+	
+	CActiveScheduler::Start();
+
+	if (iError != KErrNone)
+		 return EInconclusive;
+
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		return EInconclusive;
+
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamRead::DoTestStepPostambleL(void)
+	{
+	iFile.Close();
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+LOCAL_C TInt stopActiveScheduler(TAny*)
+	{
+	CActiveScheduler::Stop();
+	return FALSE;
+	}
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamRead::DoTestStepL()
+	{
+	StartReadL();
+
+	CCallBackTimer* timer  = CCallBackTimer::NewL(TCallBack(stopActiveScheduler));
+	timer->After(5000000); // 5s
+	CActiveScheduler::Start();
+	delete timer;
+	if (iError != KErrNone)
+		{
+		INFO_PRINTF2(_L("Test failed (iError=%d)"), iError);
+		return EFail;
+		}
+
+	iAudInStream->Stop();
+	// Now playback what we've recorded
+
+	CMdaAudioOutputStream* outputStream = CMdaAudioOutputStream::NewL(*this);
+	CleanupStack::PushL(outputStream);
+	TRAPD(err, outputStream->SetDataTypeL(iTestParameters->iEncoding));
+	
+	if (err != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(1, outputStream);
+		return EInconclusive;
+		}
+	outputStream->Open(NULL);
+	outputStream->SetVolume(outputStream->MaxVolume());
+
+	CActiveScheduler::Start(); // wait for open to complete
+	TInt size = 0;
+
+	User::LeaveIfError(iFile.Size(size));
+
+	// Read the entire file into a buffer - bit naughty but OK for test code
+	INFO_PRINTF2(_L("HBufC8:NewLC(size):  size=%d"), size);
+	HBufC8* buffer = HBufC8::NewLC(size);
+
+	INFO_PRINTF1(_L("Buffer created"));
+
+	TInt pos = 0;
+	User::LeaveIfError(iFile.Seek(ESeekStart, pos));
+	TPtr8 bufPtr = buffer->Des();
+	User::LeaveIfError(iFile.Read(bufPtr, size));
+	outputStream->WriteL(bufPtr);
+	iIsPlaying = ETrue;
+	CActiveScheduler::Start(); // wait for the play to complete
+	CleanupStack::PopAndDestroy(2); // buffer, outputStream
+	if (iError != KErrNone && iError != KErrUnderflow)
+		 return EInconclusive; // There may be a problem with the output stream rather than the input stream
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+void CTestStepAudInStreamRead::MaoscOpenComplete(TInt aError)
+	{
+	iError = aError;
+	CActiveScheduler::Stop();
+	}
+
+void CTestStepAudInStreamRead::MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	// Don't care
+	}
+
+void CTestStepAudInStreamRead::MaoscPlayComplete(TInt aError)
+	{
+	iError = aError;
+	if (iIsPlaying)
+		{
+		CActiveScheduler::Stop();
+		iIsPlaying = EFalse;
+		}
+	}
+
+void CTestStepAudInStreamRead::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
+	{
+	iError = aError;
+	CActiveScheduler::Stop();
+	}
+
+void CTestStepAudInStreamRead::MapcPlayComplete(TInt aError)
+	{
+	iError = aError;
+	CActiveScheduler::Stop();
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamStop.
+ *
+ *
+ * @return	"CTestStepAudInStreamStop*"
+ *			The constructed CTestStepAudInStreamStop
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamStop* CTestStepAudInStreamStop::NewL()
+	{
+	CTestStepAudInStreamStop* self = new(ELeave) CTestStepAudInStreamStop;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamStop::CTestStepAudInStreamStop()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0710-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamStop::~CTestStepAudInStreamStop()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamStop::DoTestStepPreambleL(void)
+	{
+	iTestStepResult = EPass;
+	enum TVerdict verdict;
+	// this installs the scheduler, and NEWLs the input stream object
+	verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0710-CP"));
+	INFO_PRINTF1(_L("this test is stopping a playing Audio Input Stream Utility Class: Stop()"));
+
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+
+	if (iError != KErrNone)
+		 return EInconclusive;
+
+	TInt err = KErrNone;
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		return EInconclusive;
+
+	// start feeding the input stream
+	StartReadL();
+	CCallBackTimer* timer  = CCallBackTimer::NewL(TCallBack(stopActiveScheduler, iAudInStream));
+	timer->After(1000000); // 1s
+	CActiveScheduler::Start();
+	delete timer;
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamStop::DoTestStepPostambleL(void)
+	{
+	iFile.Close();
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamStop::DoTestStepL()
+	{
+	iAudInStream->Stop();
+
+	TInt err = KErrNone;
+	TBool stopped = EFalse;
+	err = GetAudInStreamStopped(iAudInStream, stopped);
+	if (err != KErrNone || 
+		!stopped )
+		 return EFail;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamPosition.
+ *
+ *
+ * @return	"CTestStepAudInStreamPosition*"
+ *			The constructed CTestStepAudInStreamPosition
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamPosition* CTestStepAudInStreamPosition::NewL()
+	{
+	CTestStepAudInStreamPosition* self = new(ELeave) CTestStepAudInStreamPosition;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamPosition::CTestStepAudInStreamPosition()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0711-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamPosition::~CTestStepAudInStreamPosition()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamPosition::DoTestStepPreambleL(void)
+	{
+	iTestStepResult = EPass;
+	enum TVerdict verdict;
+	// this installs the scheduler, and NEWLs the input stream object
+	verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0711-CP"));
+	INFO_PRINTF1(_L("this test is gettig the position of a playing Audio Input Stream Utility Class: Position()"));
+
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+
+	if (iError != KErrNone)
+		 return EInconclusive;
+
+	TInt err = KErrNone;
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		return EInconclusive;
+
+	// start feeding the input stream
+	StartReadL();
+	CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard);
+	idleStopper->Start(TCallBack(stopActiveScheduler));
+	CActiveScheduler::Start();
+	delete idleStopper;
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	TBool isRecording = EFalse;
+	err = GetAudInStreamRecording(iAudInStream, isRecording);
+	if (err != KErrNone || 
+		!isRecording)
+		 return EInconclusive;
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamPosition::DoTestStepPostambleL(void)
+	{
+	iFile.Close();
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamPosition::DoTestStepL()
+	{
+	TInt err = KErrNone;
+	TInt bytes = 0;
+
+	// here the purpose is to test if the Position() function returns the 
+	// correct position with respect to the clip byte-stream position, i.e.
+	// the bytes that have been recorded so far, expressed in time (via sample rate)
+	// and not the actual real-time time difference between the beginning of the 
+	// recording and the moment we apply Position().
+	// The stream might take longer actual time to be recorded, e.g. start delay, breaks, etc.
+	// however in this case streaming from AudioInput(microphone) should be consistent
+	// but it's not the purpose of this unit test to check that it records fine and within 
+	// certain time limits.
+
+	// get the position
+	TTimeIntervalMicroSeconds pos1 = iAudInStream->Position();
+	bytes = iAudInStream->GetBytes();
+	TInt64 estimPos = (TInt64(bytes) * KMicroSecsInOneSec) / (TInt64(KSampleRate) * TInt64(KBytesPerSample));
+	CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler));
+	const TInt KWaitTime = 1000000;
+	//const TInt KTolerence = 300000; // Should be able to do better than this!
+	callBackTimer->After(KWaitTime);
+	// wait a bit
+	CActiveScheduler::Start();
+	delete callBackTimer;
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	bytes = iAudInStream->GetBytes();
+	estimPos = (TInt64(bytes) * KMicroSecsInOneSec) / (TInt64(KSampleRate) * TInt64(KBytesPerSample));
+	// get the new position
+	TTimeIntervalMicroSeconds pos2 = iAudInStream->Position();
+	if (pos2 != estimPos)
+		return EFail;
+	TInt64 diff = pos2.Int64()-pos1.Int64();
+	INFO_PRINTF2(_L("position diff: %d"), diff);
+	//if (diff < (KWaitTime-KTolerence) || diff > (KWaitTime+KTolerence))
+	//	return EFail;
+	// stop the input stream
+	iAudInStream->Stop();
+	TBool isStopped;
+	err = GetAudInStreamStopped(iAudInStream, isStopped);
+	if (err != KErrNone || 
+		!isStopped )
+		 return EFail;
+
+	// get the new position
+	TTimeIntervalMicroSeconds pos = iAudInStream->Position();
+	if (pos.Int64() != 0)
+		 return EFail;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamGetBytes.
+ *
+ *
+ * @return	"CTestStepAudInStreamGetBytes*"
+ *			The constructed CTestStepAudInStreamGetBytes
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamGetBytes* CTestStepAudInStreamGetBytes::NewL()
+	{
+	CTestStepAudInStreamGetBytes* self = new(ELeave) CTestStepAudInStreamGetBytes;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamGetBytes::CTestStepAudInStreamGetBytes()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0712-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamGetBytes::~CTestStepAudInStreamGetBytes()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamGetBytes::DoTestStepPreambleL(void)
+	{
+	iTestStepResult = EPass;
+	enum TVerdict verdict;
+	// this installs the scheduler, and NEWLs the input stream object
+	verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0712-CP"));
+	INFO_PRINTF1(_L("this test gets the bytes rendered by the H/W until this moment: GetBytes()"));
+
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+
+	if (iError != KErrNone)
+		 return EInconclusive;
+
+	TInt err = KErrNone;
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		return EInconclusive;
+
+	// start feeding the input stream
+	StartReadL();
+	CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard);
+	idleStopper->Start(TCallBack(stopActiveScheduler));
+	CActiveScheduler::Start();
+	delete idleStopper;
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	TBool isRecording = EFalse;
+	err = GetAudInStreamRecording(iAudInStream, isRecording);
+	if (err != KErrNone || 
+		!isRecording)
+		 return EInconclusive;
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamGetBytes::DoTestStepPostambleL(void)
+	{
+	iFile.Close();
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamGetBytes::DoTestStepL()
+	{
+	TInt bytes1 = iAudInStream->GetBytes();
+	CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler));
+	callBackTimer->After(2000000);	
+	CActiveScheduler::Start();
+	callBackTimer->Cancel(); // in case something else stopped the AS
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	TInt bytes2 = iAudInStream->GetBytes();
+	callBackTimer->After(1000000);
+	CActiveScheduler::Start();
+	delete callBackTimer;
+	if (iError != KErrNone)
+		return EInconclusive;
+
+	iAudInStream->Stop();
+	TInt bytes3 = iAudInStream->GetBytes();
+	TInt fileSize;
+	User::LeaveIfError(iFile.Size(fileSize));
+	
+	if (bytes1 >= bytes2 || bytes2 >= bytes3)
+		return EFail;
+
+	if (bytes3 != fileSize)
+		return EFail;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamDataType.
+ *
+ *
+ * @return	"CTestStepAudInStreamGetSetDataType*"
+ *			The constructed CTestStepAudInStreamDataType
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamDataType* CTestStepAudInStreamDataType::NewL()
+	{
+	CTestStepAudInStreamDataType* self = new(ELeave) CTestStepAudInStreamDataType;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamDataType::CTestStepAudInStreamDataType()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0730-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamDataType::~CTestStepAudInStreamDataType()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamDataType::DoTestStepPreambleL(void)
+	{
+	iTestStepResult = EPass;
+
+	CTestStepAudInStream::DoTestStepPreambleL();
+
+	return iTestStepResult;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamDataType::DoTestStepPostambleL(void)
+	{
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamDataType::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+
+	RArray<TFourCC> codecs;
+	codecs.Append(KMMFFourCCCodePCMU8);
+	codecs.Append(KMMFFourCCCodePCM16);
+	codecs.Append(KMMFFourCCCodeALAW);
+	codecs.Append(KMMFFourCCCodeMuLAW);
+	codecs.Append(KMMFFourCCCodeIMAD);
+	codecs.Append(KMMFFourCCCodePCM16B);
+	codecs.Append(KMMFFourCCCodeGSM610);
+
+	CMdaAudioInputStream* inStream = CMdaAudioInputStream::NewL(*this);
+
+	TInt numCodecs = codecs.Count();
+	for(TInt i=0; i<numCodecs; i++)
+		{
+		TRAPD(err, inStream->SetDataTypeL(codecs[i]));
+		if (err != KErrNone)
+			{
+			iTestStepResult = EFail;
+			break;
+			}
+		TFourCC fourCCReceived = inStream->DataType();
+		if (codecs[i] != fourCCReceived)
+			{
+			iTestStepResult = EFail;
+			break;
+			}
+		}
+	delete inStream;
+	codecs.Close();
+	return iTestStepResult;
+	}
+
+// --------------------------------------------
+
+/**
+ *
+ * Static constructor for CTestStepAudInStreamMemLeak.
+ *
+ *
+ * @return	"CTestStepAudInStreamMemLeak*"
+ *			The constructed CTestStepAudInStreamMemLeak
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamMemLeak* CTestStepAudInStreamMemLeak::NewL()
+	{
+	CTestStepAudInStreamMemLeak* self = new(ELeave) CTestStepAudInStreamMemLeak;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamMemLeak::CTestStepAudInStreamMemLeak()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0510-HP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamMemLeak::~CTestStepAudInStreamMemLeak()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void CTestStepAudInStreamMemLeak::MaiscOpenComplete(TInt /*aError*/)
+	{
+	}
+void CTestStepAudInStreamMemLeak::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void CTestStepAudInStreamMemLeak::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamMemLeak::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+	 return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamMemLeak::DoTestStepPostambleL(void)
+	{
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamMemLeak::DoTestStepL()
+	{
+	__MM_HEAP_MARK;
+
+	INFO_PRINTF2(_L("%S"), &iTestStepName);
+	INFO_PRINTF1(_L("this test creates & then deletes an Audio Input Stream Utility Class"));
+	INFO_PRINTF1(_L("and then checks for any memory leak"));
+
+	iAudInStream = CMdaAudioInputStream::NewL(*this);
+
+	if ( iAudInStream == NULL )
+		 iTestStepResult = EFail;
+	else 
+		 iTestStepResult = EPass;
+
+	delete iAudInStream;
+	iAudInStream = NULL;
+	__MM_HEAP_MARKEND;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+
+	}
+
+// --------------------------------------------
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+RTestStepAudInStreamBitRate::RTestStepAudInStreamBitRate()
+	{
+	iTestVerdictSet = EFalse;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0511-HP");
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void RTestStepAudInStreamBitRate::MaiscOpenComplete(TInt aError)
+	{
+	TBuf<256> message;
+	if (aError != KErrNone)
+		{
+		message.Format(_L("Open failed unexpectedly with error %d - aborting test"), aError);
+		SetSectionFailed(message);
+		CActiveScheduler::Stop();
+		}
+	else
+		{
+		TestBitRates();
+		}
+	}
+void RTestStepAudInStreamBitRate::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void RTestStepAudInStreamBitRate::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+	
+TVerdict RTestStepAudInStreamBitRate::OpenL()
+	{
+	// create and install the active scheduler
+	CActiveScheduler* sched = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(sched);
+	return EPass;
+	}
+	
+TVerdict RTestStepAudInStreamBitRate::DoTestStepL()
+	{
+	iAudInStream = CMdaAudioInputStream::NewL(*this);		
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+	__ASSERT_ALWAYS(iTestVerdictSet, User::Panic(_L("Test verdict not set"),0));
+	return iTestStepResult;
+	}
+	
+const TInt KTestBitRate = 48000 * 16;
+_LIT(KMessageNotReadyPass, "Received KErrNotReady (As Expected: H/W device has not yet been fully initialised)");
+_LIT(KMessageUnexpectedErrorFail, "Unexpected error: %d");
+
+void RTestStepAudInStreamBitRate::TestBitRates()
+	{
+	TBuf<256> message;
+	TInt err = KErrNone;
+	
+	// this will invoke the bitrate plugin but will not have
+	// initialised the datapath therefore we expect a KErrNotReady
+	// error from each call
+	
+	TRAP(err, iAudInStream->BitRateL());
+
+	if (err != KErrNotReady)
+		{
+		message.Format(KMessageUnexpectedErrorFail,err);
+		SetSectionFailed(message);
+		}
+	else
+		{
+		message.Format(KMessageNotReadyPass);
+		SetSectionPassed(message);
+		}
+		
+	RArray<TInt> array;
+	array.AppendL(KTestBitRate); // set a dummy value
+	TRAP(err, iAudInStream->GetSupportedBitRatesL(array));
+	if (array.Count() != 0)
+		{
+		SetSectionFailed(_L("array not reset after call to GetSupportedBitRates"));
+		}
+	array.Close();
+
+	if (err != KErrNotReady)
+		{
+		message.Format(KMessageUnexpectedErrorFail,err);
+		SetSectionFailed(message);
+		}
+	else
+		{
+		message.Format(KMessageNotReadyPass);
+		SetSectionPassed(message);
+		}
+
+	TRAP(err, iAudInStream->SetBitRateL(KTestBitRate));
+	if (err != KErrNotReady)
+		{
+		message.Format(KMessageUnexpectedErrorFail,err);
+		SetSectionFailed(message);
+		}
+	else
+		{
+		message.Format(KMessageNotReadyPass);
+		SetSectionPassed(message);
+		}
+	// finished with test
+	CActiveScheduler::Stop();
+	}
+
+
+ void RTestStepAudInStreamBitRate::SetSectionPassed(const TDesC& aMessage)
+	{
+	INFO_PRINTF2(_L("%S"),&aMessage);
+		
+	if (!iTestVerdictSet)
+		{
+		iTestStepResult = EPass;
+		iTestVerdictSet = ETrue;
+		}
+	if (iTestStepResult == EPass)
+		{
+		INFO_PRINTF1(_L("Section Passed - Overall Verdict PASS"));
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Section Passed - Overall Verdict FAIL"));	
+		}
+	}
+	
+void RTestStepAudInStreamBitRate::SetSectionFailed(const TDesC& aMessage)
+	{
+	// A fail will always cause the whole test to fail
+	iTestStepResult = EFail;
+	INFO_PRINTF2(_L("%S"),&aMessage);
+	INFO_PRINTF1(_L("Section Failed - Overall Verdict FAIL"));	
+	iTestVerdictSet = ETrue;
+	}
+
+
+void RTestStepAudInStreamBitRate::Close()
+	{
+	delete iAudInStream;
+	iAudInStream = NULL;
+	}
+	
+
+
+//
+// --------------------------------------------
+//
+/**
+ *
+ * Static constructor for CTestStepAudInStreamTestBitrate.
+ *
+ *
+ * @return	"CTestStepAudInStreamTestBitrate*"
+ *			The constructed CTestStepAudInStreamTestBitrate
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamTestBitrate* CTestStepAudInStreamTestBitrate::NewL()
+	{
+	CTestStepAudInStreamTestBitrate* self = new(ELeave) CTestStepAudInStreamTestBitrate;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamTestBitrate::CTestStepAudInStreamTestBitrate()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0747-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepAudInStreamTestBitrate::~CTestStepAudInStreamTestBitrate()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+ enum TVerdict CTestStepAudInStreamTestBitrate::DoTestStepPreambleL(void)
+	{
+	iTestStepResult = EPass;
+	enum TVerdict verdict;
+	// this installs the scheduler, and NEWLs the input stream object
+	verdict = CTestStepAudInStream::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0747-CP"));
+	INFO_PRINTF1(_L("this tests the bitrate custom interface implemented in DevSound"));
+
+	iAudInStream->Open(NULL);
+	CActiveScheduler::Start();
+
+	if (iError != KErrNone)
+		{
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+	err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ;
+	if (err != KErrNone)
+		{
+		return EInconclusive;
+		}
+
+	// start feeding the input stream
+	StartReadL();
+	CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard);
+	idleStopper->Start(TCallBack(stopActiveScheduler));
+	CActiveScheduler::Start();
+	delete idleStopper;
+	if (iError != KErrNone)
+		{
+		return EInconclusive;
+		}
+
+	TBool isRecording = EFalse;
+	err = GetAudInStreamRecording(iAudInStream, isRecording);
+	if (err != KErrNone || !isRecording)
+		{
+		return EInconclusive;
+		}
+
+	User::After(1000000);
+	
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepAudInStreamTestBitrate::DoTestStepPostambleL(void)
+	{
+	iFile.Close();
+	//[ Destroy the scheduler ]
+	return CTestStepAudInStream::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepAudInStreamTestBitrate::DoTestStepL()
+	{
+	TBool test1 = EFalse;
+	TBool test2 = EFalse;
+	TBool test3 = EFalse;
+	
+	// fetch the bitrate
+	TInt bitRate = 0;
+	TRAPD(err, bitRate = iAudInStream->BitRateL());
+
+	if (err == KErrNone)
+		{
+		INFO_PRINTF2(_L("BitRateL() returned %d"), bitRate);
+		test1 = ETrue;				
+		}
+	else
+		{
+		INFO_PRINTF2(_L("BitRateL() failed with error %d"), err);
+		}
+	
+	// even if test is fail we keep going so as to test APIs
+	// get the supported bitrates from the sound device
+	RArray<TInt> array;
+	TRAP(err, iAudInStream->GetSupportedBitRatesL(array));
+	
+	if ((err == KErrNone) && (array.Count() > 0))
+		{
+		INFO_PRINTF2(_L("GetSupportedBitRatesL() returned %d result"), array.Count());
+		test2 = ETrue;
+		}
+	else if (err != KErrNone) 
+		{
+		INFO_PRINTF2(_L("GetSupportedBitRatesL() failed with error %d"), err);
+		}
+	else if (array.Count() == 0)
+		{
+		INFO_PRINTF2(_L("GetSupportedBitRatesL() returned no supported bitrates!"), err);
+		}
+	
+	// set a required bitrate - we assume num of channels
+	// has already been set as mono (1)
+	TRAP(err, iAudInStream->SetBitRateL(KTestBitRate));
+	
+	if (err == KErrNone)
+		{
+		INFO_PRINTF2(_L("SetBitRateL() set successfully at %d"), KTestBitRate);
+		test3 = ETrue;
+		}
+	else
+		{
+		INFO_PRINTF2(_L("SetBitRateL() failed with error %d"), err);
+		}
+	
+	iTestStepResult = EFail;
+	
+	if (test1 && test2 && test3)
+		{
+		iTestStepResult = EPass;
+		}
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+//
+
+RTestStepAudInStreamBitRateOOM* RTestStepAudInStreamBitRateOOM::NewL()
+	{
+	RTestStepAudInStreamBitRateOOM* self = new(ELeave) RTestStepAudInStreamBitRateOOM;
+	return self;
+	}
+	
+RTestStepAudInStreamBitRateOOM::RTestStepAudInStreamBitRateOOM()
+	{
+	iTestStepResult = EPass;
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0748-CP");
+	}
+	
+RTestStepAudInStreamBitRateOOM::~RTestStepAudInStreamBitRateOOM()
+	{
+	}
+
+/**
+ * Implementation of the MMdaAudioOuputStreamCallback interface functions
+ **/
+void RTestStepAudInStreamBitRateOOM::MaiscOpenComplete(TInt aError)
+	{
+	if (aError != KErrNone)
+		{
+		INFO_PRINTF2(_L("Open failed unexpectedly with error %d - aborting test"), aError);
+		iTestStepResult = EFail;
+		}
+	CActiveScheduler::Stop();
+	}
+void RTestStepAudInStreamBitRateOOM::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
+	{
+	}
+void RTestStepAudInStreamBitRateOOM::MaiscRecordComplete(TInt /*aError*/)
+	{
+	}
+	
+	
+TVerdict RTestStepAudInStreamBitRateOOM::TestBitRateInterfaceL()	
+	{
+	// create the stream
+	CMMFMdaAudioInputStream* inStream = CMMFMdaAudioInputStream::NewL(*this);
+	CleanupStack::PushL(inStream);
+	
+	// open it and start the scheduler
+	inStream->Open(NULL);
+	CActiveScheduler::Start();
+
+		
+	// we trap all calls to catch the KErrNotReady error
+	// now fetch the bitrate
+	TRAPD(err, inStream->BitRateL());
+	if (err != KErrNone && err != KErrNotReady)
+		{
+		User::Leave(err);
+		}
+
+	// fetch a list of bitrates
+	RArray<TInt> array;
+	TRAP(err, inStream->GetSupportedBitRatesL(array));
+	if (err != KErrNone && err != KErrNotReady)
+		{
+		User::Leave(err);
+		}
+	
+	// set a required bitrate - we assume num of channels
+	// has already been set as mono (1)
+	TRAP(err, inStream->SetBitRateL(KTestBitRate))
+	if (err != KErrNone && err != KErrNotReady)
+		{
+		User::Leave(err);
+		}
+	
+	// clean up
+	CleanupStack::PopAndDestroy(inStream);
+	inStream = NULL;
+	
+	return EPass;
+	}
+
+
+
+TVerdict RTestStepAudInStreamBitRateOOM::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+
+	CActiveScheduler* sched = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(sched);
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0748-CP"));
+	INFO_PRINTF1(_L("this tests the bitrate custom interface implemented in DevSound for OOM"));
+
+	//__MM_HEAP_MARK;
+	TVerdict testRes = EFail;
+	TRAP( err, testRes = TestBitRateInterfaceL());
+	//__MM_HEAP_MARKEND;
+
+	if (err != KErrNone || testRes == EFail)
+		return EFail;
+
+	TInt failCount = 1;
+	TBool completed = EFalse;
+	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging
+	for(;;)	
+		{
+		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);
+		//__MM_HEAP_MARK;
+		
+		testRes = EFail;
+		TRAP( err, testRes = TestBitRateInterfaceL());
+
+		completed = EFalse;
+		if (err == KErrNone)
+			{
+			if (testRes == EPass)
+				{
+				TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test
+				if (testAlloc==NULL)
+					{
+					reachedEnd = ETrue;
+					failCount--; // -= 1;
+					}
+				else
+					{
+					User::Free(testAlloc);
+					}
+				completed = reachedEnd;
+				}
+			else
+				{
+				// the test failed but we have already proved above
+				// that the required plugins are present
+				// therefore we assume that the interface returned
+				// a NULL pointer and so we can continue to test
+				// until the timeout or the fail count exceeds
+				completed = EFalse;
+				}
+			}
+		else if (err == KErrNotSupported)
+			{
+			// the test has returned not supported but we already
+			// know that the interface *is* supported so we assume
+			// that the interface creation failed due to lack of
+			// memory and so we continue to test until the timeout
+			// or we exceed the fail count
+			completed = EFalse;
+			}
+		else if (err != KErrNoMemory) // bad error code
+			{
+			completed = ETrue;
+			}
+				
+		//__MM_HEAP_MARKEND;
+		__UHEAP_SETFAIL(RHeap::ENone ,0);
+
+		// if we have completed successfully or we have exceeded
+		// a 1000 failed ALLOC attempts then quit
+		if (completed || failCount > 1000)
+			break; // exit loop
+
+		failCount++;
+		}
+
+	// finished with test
+
+	if (err != KErrNone)
+		{
+		INFO_PRINTF3(_L("  Error(%d) with %d memory allocations tested"), err, failCount);
+		iTestStepResult = EFail;
+		}
+	else 
+		{
+		INFO_PRINTF2(_L("  Completed OK with %d memory allocations tested"), failCount);
+		iTestStepResult = EPass;
+		}
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+	
+	
+
+//
+// RAsyncTestStep Tests
+//
+
+/**
+ * Base class common implementation 
+ **/
+ 
+CTestStepAudInStreamAsyncTestStep::CTestStepAudInStreamAsyncTestStep(CTestSuite* aSuite)
+// Using zero initialisation
+//	iTestState (EStateOpen)
+//	iBufferList
+//	iBufferCount
+//	iAudInStream
+//	iTrigger
+	{
+	iSuite = aSuite;
+	//Default heap size is 64K. Increased to 128K to avoid the KErrNoMemory for this test step.
+	iHeapSize = 1024*128;
+	}
+
+void CTestStepAudInStreamAsyncTestStep::KickoffTestL()
+	{
+	iTrigger = CFsmTrigger::NewL(*this);
+	iAudInStream = CMdaAudioInputStream::NewL(*this);
+	
+	// Reset the buffer. 
+	// We need them empty as could test whether data has been placed into them to obtain some stats.
+	for(TInt i=0; i<KNumBuffers; i++)
+		{
+		iBufferList[i] = KNullDesC8;
+		}
+
+	// start the timer
+	iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+	iTrigger->StartTimer(500000);
+	}
+		
+// cleanup at end
+void CTestStepAudInStreamAsyncTestStep::CloseTest()
+	{
+	if (iTrigger)
+		{
+		iTrigger->Cancel();
+		delete iTrigger;
+		}
+	
+	if (iAudInStream)
+		{
+		delete iAudInStream;
+		}
+	}
+
+void CTestStepAudInStreamAsyncTestStep::MaiscOpenComplete(TInt aError)
+	{
+	if (aError != KErrNone)
+		{
+		INFO_PRINTF2(_L("*MaiscOpenComplete* Error: %d."), aError);
+		StopTest(aError, EFail);
+		}
+	}
+
+void CTestStepAudInStreamAsyncTestStep::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer)
+	{	
+	if (aBuffer.Length())
+		{
+		++iBufferCount;
+		}
+
+	if (aError != KErrNone)
+		{
+		INFO_PRINTF2(_L("*MaiscBufferCopied* Error: %d."), aError);
+		
+		// KErrAbort when we Stop the device, so valid
+		if (aError != KErrAbort)
+			{
+			StopTest(aError, EFail);			
+			}
+		}
+	}
+
+void CTestStepAudInStreamAsyncTestStep::MaiscRecordComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("*MaiscRecordComplete* GetBytes reports %d bytes recorded."), iAudInStream->GetBytes());
+
+	if (aError != KErrNone)
+		{
+		INFO_PRINTF2(_L("*MaiscRecordComplete* Error: %d."), aError);
+		StopTest(aError, EFail);
+		}
+	}
+
+//
+/**
+ * Implementation of AO timer used to invoke test processing at desired intervals (i.e. State Machine)
+ **/
+
+CFsmTrigger* CFsmTrigger::NewL(CTestStepAudInStreamAsyncTestStep& aObserver)
+	{
+	CFsmTrigger* self = new (ELeave) CFsmTrigger(aObserver);	
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);	
+	return self;
+	}
+
+CFsmTrigger::CFsmTrigger(CTestStepAudInStreamAsyncTestStep& aObserver)
+:	CActive(CActive::EPriorityStandard),
+	iObserver (aObserver)
+	{
+	// nothing to do
+	}
+
+void CFsmTrigger::ConstructL()
+	{
+	User::LeaveIfError (iTimer.CreateLocal());
+	CActiveScheduler::Add (this);
+	}
+	
+CFsmTrigger::~CFsmTrigger()
+	{
+	Cancel();
+	iTimer.Close();
+	}
+	
+void CFsmTrigger::RunL()
+	{
+	// need to call Fsm
+	iObserver.Fsm();
+	}
+
+void CFsmTrigger::DoCancel()
+	{
+	iTimer.Cancel();
+	}
+
+void CFsmTrigger::StartTimer(TTimeIntervalMicroSeconds32 aDelay)
+	{
+	__ASSERT_ALWAYS(!IsActive(), User::Panic(_L("CFsmTrigger"), 1));
+	iTimer.After(iStatus, aDelay);
+	SetActive();
+	}
+
+//
+/**
+ * Implementation of RAsyncTestStep used to test the RequestStop() api
+ **/
+
+CTestStepAudInStreamTestReqStop* CTestStepAudInStreamTestReqStop::NewL(CTestSuite* aSuite)
+	{
+	return new (ELeave) CTestStepAudInStreamTestReqStop(aSuite);
+	}
+
+CTestStepAudInStreamTestReqStop::CTestStepAudInStreamTestReqStop(CTestSuite* aSuite)
+: CTestStepAudInStreamAsyncTestStep(aSuite)
+	{
+	iTestStepName = _L("MM-MMF-ACLNT-U-0749-CP");
+	}
+
+void CTestStepAudInStreamTestReqStop::KickoffTestL()
+	{
+	INFO_PRINTF1(_L("DEF095804 CMdaAudioInputStream loses not complete buffers from DevSound"));
+	INFO_PRINTF1(_L("Calls RequestStop to ensure no data is lost."));
+
+	CTestStepAudInStreamAsyncTestStep::KickoffTestL();
+	}
+		
+// cleanup at end
+void CTestStepAudInStreamTestReqStop::CloseTest()
+	{
+	CTestStepAudInStreamAsyncTestStep::CloseTest();
+	}
+
+void CTestStepAudInStreamTestReqStop::MaiscOpenComplete(TInt aError)
+	{
+	CTestStepAudInStreamAsyncTestStep::MaiscOpenComplete(aError);
+	}
+
+void CTestStepAudInStreamTestReqStop::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer)
+	{	
+	CTestStepAudInStreamAsyncTestStep::MaiscBufferCopied(aError, aBuffer);
+	
+	if (aError == KErrAbort)
+		{
+		INFO_PRINTF2(_L("*MaiscBufferCopied* Error EXPECTED. We have been Stopped."), aError);			
+		INFO_PRINTF2(_L("*MaiscBufferCopied* Data in this buffer: %d bytes."), aBuffer.Length());
+		INFO_PRINTF2(_L("*MaiscBufferCopied* GetBytes reports %d bytes recorded."), iAudInStream->GetBytes());
+		}
+	}
+
+void CTestStepAudInStreamTestReqStop::MaiscRecordComplete(TInt aError)
+	{
+	CTestStepAudInStreamAsyncTestStep::MaiscRecordComplete(aError);
+	}
+
+void CTestStepAudInStreamTestReqStop::Fsm()
+	{
+	switch (iTestState)
+		{
+	case EStateOpen:
+		{
+		iAudInStream->Open(NULL);
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000); 
+		iTestState = EStateRecordInit;
+		break;
+		}
+	case EStateRecordInit:
+		{
+		// start the recording process
+		for (TInt i=0; i<KNumBuffers; i++)
+			{
+			iAudInStream->ReadL(iBufferList[i]);
+			}
+		
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+		iTestState = EStateRecord;
+		break;
+		}
+	case EStateRecord:
+		{	
+		// Just wating time here...for the record process to continue
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+		iTestState = EStateRequestStop;
+		break;
+		}
+	case EStateRequestStop:
+		{		
+		// stop the recording process
+		iAudInStream->RequestStop();	
+
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+
+		// report the number of bytes read
+		INFO_PRINTF2(_L("State: EStateRequestStop - GetBytes reports %d bytes recorded."), iAudInStream->GetBytes());
+		iTestState = EStateStopTest;
+		break;			
+		}
+	case EStateStopTest:
+		{
+		INFO_PRINTF3(_L("Used %d buffers of %d."), iBufferCount, KNumBuffers);
+		StopTest(); // success
+		break;					
+		}
+	default:
+		INFO_PRINTF1(_L("State machine error"));
+		StopTest(KErrGeneral, EFail);
+		break;
+		}		
+	}
+	
+//
+/**
+ * Implementation of RAsyncTestStep used to test the RequestStop() then Stop() apis
+ **/
+
+CTestStepAudInStreamTestReqStopThenStop* CTestStepAudInStreamTestReqStopThenStop::NewL(CTestSuite* aSuite)
+	{
+	return new (ELeave) CTestStepAudInStreamTestReqStopThenStop(aSuite);
+	}
+
+CTestStepAudInStreamTestReqStopThenStop::CTestStepAudInStreamTestReqStopThenStop(CTestSuite* aSuite)
+: CTestStepAudInStreamAsyncTestStep(aSuite)
+	{
+	iTestStepName = _L("MM-MMF-ACLNT-U-0750-CP");
+	}
+
+void CTestStepAudInStreamTestReqStopThenStop::KickoffTestL()
+	{
+	INFO_PRINTF1(_L("DEF095804 CMdaAudioInputStream loses not complete buffers from DevSound"));
+	INFO_PRINTF1(_L("Calls RequestStop then Stop to ensure correct operation."));
+
+	CTestStepAudInStreamAsyncTestStep::KickoffTestL();
+	}
+		
+// cleanup at end
+void CTestStepAudInStreamTestReqStopThenStop::CloseTest()
+	{
+	CTestStepAudInStreamAsyncTestStep::CloseTest();
+	}
+
+void CTestStepAudInStreamTestReqStopThenStop::MaiscOpenComplete(TInt aError)
+	{
+	CTestStepAudInStreamAsyncTestStep::MaiscOpenComplete(aError);
+	}
+
+void CTestStepAudInStreamTestReqStopThenStop::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer)
+	{	
+	CTestStepAudInStreamAsyncTestStep::MaiscBufferCopied(aError, aBuffer);
+	
+	if (aError == KErrAbort)
+		{
+		INFO_PRINTF2(_L("*MaiscBufferCopied* Error EXPECTED. We have been Stopped."), aError);			
+		INFO_PRINTF2(_L("*MaiscBufferCopied* Data in this buffer: %d bytes."), aBuffer.Length());
+		INFO_PRINTF2(_L("*MaiscBufferCopied* GetBytes reports %d bytes recorded."), iAudInStream->GetBytes());
+		}
+	}
+
+void CTestStepAudInStreamTestReqStopThenStop::MaiscRecordComplete(TInt aError)
+	{
+	CTestStepAudInStreamAsyncTestStep::MaiscRecordComplete(aError);
+	}
+
+void CTestStepAudInStreamTestReqStopThenStop::Fsm()
+	{
+	switch (iTestState)
+		{
+	case EStateOpen:
+		{
+		iAudInStream->Open(NULL);
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000); 
+		iTestState = EStateRecordInit;
+		break;
+		}
+	case EStateRecordInit:
+		{
+		// start the recording process
+		for (TInt i=0; i<KNumBuffers; i++)
+			{
+			iAudInStream->ReadL(iBufferList[i]);
+			}
+		
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+		iTestState = EStateRecord;
+		break;
+		}
+	case EStateRecord:
+		{	
+		// Just wating time here...for the record process to continue
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+		iTestState = EStateRequestStop;
+		break;
+		}
+	case EStateRequestStop:
+		{		
+		// stop the recording process
+		iAudInStream->RequestStop();	
+		iAudInStream->Stop();	
+
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+
+		// report the number of bytes read
+		INFO_PRINTF2(_L("State: EStateRequestStop - GetBytes reports %d bytes recorded."), iAudInStream->GetBytes());
+		iTestState = EStateStopTest;
+		break;			
+		}
+	case EStateStopTest:
+		{
+		INFO_PRINTF3(_L("Used %d buffers of %d."), iBufferCount, KNumBuffers);
+		StopTest(); // success
+		break;					
+		}
+	default:
+		INFO_PRINTF1(_L("State machine error"));
+		StopTest(KErrGeneral, EFail);
+		break;
+		}		
+	}
+	
+//
+
+/**
+ * Implementation of RAsyncTestStep used to test the RequestStop() then Stop() apis
+ **/
+
+CTestStepAudInStreamTestStopFromBufferCopied* CTestStepAudInStreamTestStopFromBufferCopied::NewL(CTestSuite* aSuite)
+	{
+	return new (ELeave) CTestStepAudInStreamTestStopFromBufferCopied(aSuite);
+	}
+
+CTestStepAudInStreamTestStopFromBufferCopied::CTestStepAudInStreamTestStopFromBufferCopied(CTestSuite* aSuite)
+: CTestStepAudInStreamAsyncTestStep(aSuite)
+	{
+	iTestStepName = _L("MM-MMF-ACLNT-U-0751-CP");
+	}
+
+void CTestStepAudInStreamTestStopFromBufferCopied::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer)
+	{	
+	CTestStepAudInStreamAsyncTestStep::MaiscBufferCopied(aError, aBuffer);
+	if(iTestState == EStateRequestStop)
+		{
+		iTestState = EStateStopping;
+		iAudInStream->Stop();
+		iTestState = EStateStopTest;
+		Fsm();
+		}
+	}
+
+void CTestStepAudInStreamTestStopFromBufferCopied::Fsm()
+	{
+	switch (iTestState)
+		{
+	case EStateOpen:
+		{
+		iAudInStream->Open(NULL);
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000); 
+		iTestState = EStateRecordInit;
+		break;
+		}
+	case EStateRecordInit:
+		{
+		// start the recording process
+		for (TInt i=0; i<KNumBuffers; i++)
+			{
+			TRAPD(err, iAudInStream->ReadL(iBufferList[i]));
+			if(err)
+				{
+				INFO_PRINTF2(_L("ReadL failed with error[%d]."), err);
+				StopTest(err, EFail);
+				return;
+				}
+			}
+		
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000);
+		iTestState = EStateRecord;
+		break;
+		}
+	case EStateRecord:
+		{	
+		// Just wating time here...for the record process to continue
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTestState = EStateRequestStop;
+		break;
+		}
+	case EStateStopTest:
+		{
+		INFO_PRINTF3(_L("Used %d buffers of %d."), iBufferCount, KRecNumBuffer);
+		StopTest(); // success
+		break;					
+		}
+	default:
+		INFO_PRINTF1(_L("State machine error"));
+		StopTest(KErrGeneral, EFail);
+		break;
+		}		
+	}
+
+
+//
+
+/**
+ * 
+ **/
+
+CTestStepAudInStreamDestroy* CTestStepAudInStreamDestroy::NewL(CTestSuite* aSuite)
+	{
+	return new (ELeave) CTestStepAudInStreamDestroy(aSuite);
+	}
+
+CTestStepAudInStreamDestroy::CTestStepAudInStreamDestroy(CTestSuite* aSuite)
+: CTestStepAudInStreamAsyncTestStep(aSuite)
+	{
+	iTestStepName = _L("MM-MMF-ACLNT-U-0985-CP");
+	}
+
+void CTestStepAudInStreamDestroy::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer)
+	{	
+	INFO_PRINTF2(_L("*MaiscBufferCopied* Error: %d."), aError);
+	if (aError==KErrNone && aBuffer.Length())
+			{
+			++iBufferCount;
+			}
+
+	else
+			{
+			if (aError == KErrAbort)
+				{
+				INFO_PRINTF1(_L("Unexpected call back Received when input stream has been deleted"));
+				}
+			StopTest(aError, EFail);			
+			
+			}	
+	}
+
+void CTestStepAudInStreamDestroy::Fsm()
+	{
+	switch (iTestState)
+		{
+	case EStateOpen:
+		{
+		iAudInStream->Open(NULL);
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(500000); 
+		iTestState = EStateRecordInit;
+		break;
+		}
+	case EStateRecordInit:
+		{
+		// start the recording process
+		for (TInt i=0; i<KNumBuffers; i++)
+			{
+			TRAPD(err, iAudInStream->ReadL(iBufferList[i]));
+			if(err)
+				{
+				INFO_PRINTF2(_L("ReadL failed with error[%d]."), err);
+				StopTest(err, EFail);
+				return;
+				}
+			}
+		
+		// start the timer
+		iTrigger->Cancel(); // ensure assert in StartTimer always succeeds
+		iTrigger->StartTimer(1000000);
+		iTestState = EStateStopTest;
+		break;
+		}
+	
+	case EStateStopTest:
+		{
+		//Now call delete to invoke the destructor
+		INFO_PRINTF1(_L("Deleting Input Stream"));
+		delete iAudInStream;
+		iAudInStream=NULL;
+		INFO_PRINTF3(_L("Used %d buffers of %d."), iBufferCount, KNumBuffers);
+		StopTest(); // success
+		break;					
+		}
+	default:
+		INFO_PRINTF1(_L("State machine error"));
+		StopTest(KErrGeneral, EFail);
+		break;
+		}		
+	}