--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepRecorderRecord.cpp	Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,2540 @@
+// 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>
+#include <testframework.h>
+
+//#include <MdaAudioSamplePlayer.h>
+#include <mdaaudiosampleeditor.h>
+//#include <MdaAudioTonePlayer.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 "TestStepRecorder.h"
+
+
+#include "MmfAudioController.h"
+#include "mmfclientaudiorecorder.h"
+//#include "MmfClientAudioPlayer.h"
+//#include <mmffourcc.h>
+//#include <mmfpaniccodes.h>
+//#include <mmfFormatImplementationUIDs.hrh>
+// --------------------------------------------
+
+const TInt KTestRecordTime = 10000000;				// 10 sec
+const TInt KTestRecordTimeTolerance = 2000000;		// 2 sec
+const TInt KTestPointerValue = 0xdeadbeef;
+const TInt KTestPointerRecorder1 = 0xdadadada;
+const TInt KTestPointerRecorder2 = 0xbabababa;
+
+_LIT(KTestRecordOne, "c:\\R1.wav");
+_LIT(KTestRecordTwo, "c:\\R2.wav");
+_LIT(KTestRecordThree, "c:\\R3.wav");
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecord.
+ *
+ *
+ * @return	"CTestStepRecorderRecord*"
+ *			The constructed CTestStepRecorderRecord
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecord* CTestStepRecorderRecord::NewL()
+	{
+	CTestStepRecorderRecord* self = new(ELeave) CTestStepRecorderRecord;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecord::CTestStepRecorderRecord() : iError(0), iHasRecorded(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-0207-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecord::~CTestStepRecorderRecord()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecord::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0207-CP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL"));
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord"), iFileName))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord2"), iFileName2))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord3"), iFileName3))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		verdict = EInconclusive;
+
+	return verdict;
+
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecord::DoTestStepPostambleL(void)
+	{
+	//delete the output file
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderRecord::MoscoStateChangeEvent(CBase* aObject,
+														  TInt /*aPreviousState*/,
+														  TInt /*aCurrentState*/,
+														  TInt aErrorCode)
+	{
+	if (aObject != REINTERPRET_CAST(CBase*, KTestPointerValue))
+		iError = KErrArgument;
+	else
+		iError = aErrorCode;
+	CActiveScheduler::Stop();
+	}
+
+// this can return a TBool hasPlayed to prove that it has played
+// but the EPlaying state seems to get preserved for some reason...
+void CTestStepRecorderRecord::RecordAndStartSchedulerL()
+	{
+	iRecorder->RecordL();
+	CActiveScheduler::Start();
+	// record 2 secs, ...probably silence
+	User::After(2000000);
+
+    if (iRecorder->State() == CMdaAudioRecorderUtility::ERecording)
+		iHasRecorded = ETrue;
+	iRecorder->Stop();
+	User::LeaveIfError(iError);
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepRecorderRecord::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	/*
+	// record AU file //
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName2);
+	CActiveScheduler::Start();
+	if (iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()*.75);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	// record RAW file //
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName3);
+	CActiveScheduler::Start();
+	if (iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()*.75);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+	*/
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordWav.
+ *
+ *
+ * @return	"CTestStepRecorderRecordWav*"
+ *			The constructed CTestStepRecorderRecordWav
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordWav* CTestStepRecorderRecordWav::NewL()
+	{
+	CTestStepRecorderRecordWav* self = new(ELeave) CTestStepRecorderRecordWav;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordWav::CTestStepRecorderRecordWav() : iError(0), iHasRecorded(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-0269-HP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordWav::~CTestStepRecorderRecordWav()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordWav::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0269-HP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL with non existent wav file"));
+
+	// set the file name to something weird
+    iFileName.Set( _L("c:\\szhgefdsfe.wav"));
+
+	//[ ensure the file does not exist]
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);
+
+	TRAPD( errorCode, iRecorder->CropL() );
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen ||
+		 errorCode != KErrNone )
+		{
+		 INFO_PRINTF3( _L("Failed after Crop in preamble: (iError, errorCode)  %x, %x"), iError, errorCode );
+		 verdict = EInconclusive;
+		}
+
+	return verdict;
+
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordWav::DoTestStepPostambleL(void)
+	{
+	//delete the output file
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderRecordWav::MoscoStateChangeEvent(CBase* aObject,
+														  TInt /*aPreviousState*/,
+														  TInt /*aCurrentState*/,
+														  TInt aErrorCode)
+	{
+	if (aObject != REINTERPRET_CAST(CBase*, KTestPointerValue))
+		iError = KErrArgument;
+	else
+		iError = aErrorCode;
+	CActiveScheduler::Stop();
+	}
+
+// this can return a TBool hasPlayed to prove that it has played
+// but the EPlaying state seems to get preserved for some reason...
+void CTestStepRecorderRecordWav::RecordAndStartSchedulerL()
+	{
+	iRecorder->RecordL();
+	CActiveScheduler::Start();
+	// record 2 secs, ...probably silence
+	User::After(2000000);
+
+	if (iRecorder->State() == CMdaAudioRecorderUtility::ERecording)
+		iHasRecorded = ETrue;
+	iRecorder->Stop();
+	User::LeaveIfError(iError);
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepRecorderRecordWav::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+
+
+/**
+*
+* CTestStepRecorderRecordAu
+*
+*/
+
+CTestStepRecorderRecordAu::CTestStepRecorderRecordAu()
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0270-HP");
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordAu.
+ *
+ *
+ * @return	"CTestStepRecorderRecordAu*"
+ *			The constructed CTestStepRecorderRecordAu
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordAu* CTestStepRecorderRecordAu::NewL()
+	{
+	CTestStepRecorderRecordAu* self = new(ELeave) CTestStepRecorderRecordAu();
+	return self;
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordAu::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0270-HP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL with non existent wav file"));
+
+	// set the file name to something weird
+    iFileName.Set( _L("c:\\szhgefdsfe.au"));
+
+	//[ ensure the file does not exist]
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);
+
+	iRecorder->CropL(); //debug code remove
+
+	TRAPD( errorCode, iRecorder->CropL() );
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen ||
+		 errorCode != KErrNone )
+		{
+	    INFO_PRINTF3(_L("Test Failed after Crop operation in preamble: (iError, errorCode) (%X, %X)"),iError, errorCode );
+		verdict = EInconclusive;
+		}
+
+	return verdict;
+
+	}
+
+
+CTestStepRecorderRecordRaw::CTestStepRecorderRecordRaw()
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0271-CP");
+	}
+
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordRaw::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0271-CP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL with non existent raw file"));
+
+	// set the file name to something weird
+    iFileName.Set( _L("c:\\szhgefdsfe.raw"));
+
+	//[ ensure the file does not exist]
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);
+	TRAPD( errorCode, iRecorder->CropL())
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen ||
+		 errorCode != KErrNone )
+		{
+		INFO_PRINTF3(_L("Test Failed after Crop operation in preamble: (iError, errorCode)(%X, %X)"),iError, errorCode );
+		verdict = EInconclusive;
+		}
+
+	return verdict;
+
+	}
+
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordAu.
+ *
+ *
+ * @return	"CTestStepRecorderRecordRaw*"
+ *			The constructed CTestStepRecorderRecordRaw
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordRaw* CTestStepRecorderRecordRaw::NewL()
+	{
+	CTestStepRecorderRecordRaw* self = new(ELeave) CTestStepRecorderRecordRaw;
+	return self;
+	}
+
+
+/**
+*
+* CTestStepRecorderRecordWavGsm
+*/
+
+CTestStepRecorderRecordWavGsm::CTestStepRecorderRecordWavGsm() 
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0275-HP");
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordWavGsm.
+ *
+ *
+ * @return	"CTestStepRecorderRecordWavGsm*"
+ *			The constructed CTestStepRecorderRecordWavGsm
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderRecordWavGsm* CTestStepRecorderRecordWavGsm::NewL()
+	{
+	CTestStepRecorderRecordWavGsm* self = new(ELeave) CTestStepRecorderRecordWavGsm();
+	return self;
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderRecordWavGsm::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0275-HP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL with non existent wav Gsm file"));
+
+	// set the file name to something weird
+    iFileName.Set( _L("c:\\asmeraGSM610.wav"));
+	
+	//[ ensure the file does not exist]
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		{
+		verdict = EInconclusive;
+		}
+	
+	TInt result = SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue));
+	
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("SetAudRecorderParent returned %d"), result);
+		return EFail; // check value in MoscoStateChangeEvent
+		}
+
+
+	// open an existing file to record and crop all its contents if any
+	TRAPD( errorCode, iRecorder->OpenFileL(iFileName,
+						 				   TUid::Uid(KMmfUidControllerAudio),
+										   TUid::Null(),
+										   TUid::Uid(KMmfUidFormatWAVWrite),
+										   TFourCC(KMMFFourCCCodeGSM610)) );
+	CActiveScheduler::Start(); 
+	
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);	
+	
+	if ( errorCode != KErrNone || iError != KErrNone || iRecorder->State() != CMdaAudioRecorderUtility::EOpen )
+		{
+	    INFO_PRINTF3(_L("Test Failed after open operation in preamble: (iError, errorCode) (%d, %d)"),iError, errorCode );
+		verdict = EInconclusive;
+		}
+		
+	return verdict;
+
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepRecorderRecordWavGsm::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+	TInt count;
+	
+	for (count = 0; count < 3; count++)
+		{
+		iHasRecorded = EFalse;
+		
+		TRAP( err, iRecorder->RecordL() );
+
+		User::After(KTestRecordTime);
+	
+		if (iRecorder->State() == CMdaAudioRecorderUtility::ERecording)
+			{
+			iHasRecorded = ETrue;
+			}
+			
+		iRecorder->Stop();
+		CActiveScheduler::Start();
+		}
+	
+	TInt recordedDuration;
+	TInt expectedDuration;
+	
+	recordedDuration = iRecorder->Duration().Int64() + (KTestRecordTimeTolerance * count);
+	expectedDuration = KTestRecordTime * count;
+	
+	if ( iHasRecorded && (recordedDuration < expectedDuration) )
+		{
+		INFO_PRINTF4(_L("Test failed Recorded: %d and Expected: %d duration mismatch. iHasRecorded %d"),
+					     recordedDuration, expectedDuration, iHasRecorded);
+		return EFail;
+		}
+
+	// check result
+	if (iError != KErrNone || err != KErrNone || !iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		{
+		INFO_PRINTF3(_L("Test Failed to record: (iError, errorCode) (%d, %d)"),iError, err);
+		return EFail;
+		}
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+
+/**
+*
+* CTestStepRecorderRecordWavGsmFail
+*/
+
+CTestStepRecorderRecordWavGsmFail::CTestStepRecorderRecordWavGsmFail() 
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0276-HP");
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordWavGsmFail.
+ *
+ *
+ * @return	"CTestStepRecorderRecordWavGsmFail*"
+ *			The constructed CTestStepRecorderRecordWavGsmFail
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderRecordWavGsmFail* CTestStepRecorderRecordWavGsmFail::NewL()
+	{
+	CTestStepRecorderRecordWavGsmFail* self = new(ELeave) CTestStepRecorderRecordWavGsmFail();
+	return self;
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderRecordWavGsmFail::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0276-HP"));
+	INFO_PRINTF1(_L("This is a test to append to a corrupted wav Gsm file"));
+
+	// set the file name
+    _LIT(KSoundFile, "c:\\mm\\mmf\\testfiles\\aclnt\\corruptedGsm610Mono8khz.wav");
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		{
+		verdict = EInconclusive;
+		}
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(KSoundFile);
+	CActiveScheduler::Start();
+	
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}	
+
+	if (iError != KErrNone || iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		{
+		return EInconclusive;
+		}
+
+	TRAPD(errorCode, iRecorder->PlayL());
+	CActiveScheduler::Start();					// state change call back
+	
+	if (errorCode != KErrNone || iError == KErrCorrupt || (iRecorder->State() != CMdaAudioRecorderUtility::EPlaying) )
+		{
+		INFO_PRINTF4(_L("Test Failed attempting to paly: (iError, errorCode, State) (%d, %d, %d)"),
+					iError, errorCode, iRecorder->State() );		
+		return EFail;	
+		}
+		
+	CActiveScheduler::Start();					// PlayL()
+	iRecorder->Stop();
+	
+	
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(KSoundFile,
+						 TUid::Uid(KMmfUidControllerAudio),
+						 TUid::Null(),
+						 TUid::Uid(KMmfUidFormatWAVWrite),
+						 TFourCC(KMMFFourCCCodeGSM610) );
+	CActiveScheduler::Start();
+	
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+	
+	if ( errorCode != KErrNone || iError != KErrNone || iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		{
+	    INFO_PRINTF3(_L("Test Failed in CTestStepRecorderRecordWavGsmFail::DoTestStepPreambleL: (iError, errorCode) (%d, %d)"),iError, errorCode );
+		verdict = EInconclusive;
+		}
+		
+	return verdict;
+
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepRecorderRecordWavGsmFail::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+
+	
+	TRAP( err, iRecorder->RecordL() );
+	CActiveScheduler::Start();
+
+	iRecorder->Stop();
+	
+	if (iError == KErrCorrupt)
+	{
+		iError = KErrNone;
+		iTestStepResult = EPass;	
+	}
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderRecordPause.
+ *
+ *
+ * @return	"CTestStepRecorderRecordPause*"
+ *			The constructed CTestStepRecorderRecordPause
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordPause* CTestStepRecorderRecordPause::NewL(const TDesC& aTestName)
+	{
+	CTestStepRecorderRecordPause* self = new(ELeave) CTestStepRecorderRecordPause(aTestName);
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordPause::CTestStepRecorderRecordPause(const TDesC& aTestName) : iError(0), iHasRecorded(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-0210-CP");
+	//iTestStepName = _L("MM-MMF-ACLNT-U-0211-CP");
+	iTestStepName = aTestName;
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderRecordPause::~CTestStepRecorderRecordPause()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordPause::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::RecordL"));
+	
+	_LIT(K210Test,"MM-MMF-ACLNT-U-0210-CP");
+	_LIT(K211Test,"MM-MMF-ACLNT-U-0211-CP");    //  Test step added for DEF140670
+	
+	if(iTestStepName == K210Test)
+	    {
+	    if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord"), iFileName))
+            {
+            //INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+            return EInconclusive;
+            }
+	    }
+	else if(iTestStepName == K211Test)
+	    {
+       if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord1"), iFileName))
+            {
+            return EInconclusive;
+            }
+	    }	
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord2"), iFileName2))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToRecord3"), iFileName3))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+	
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iBeginning = new TTimeIntervalMicroSeconds(0);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		verdict = EInconclusive;
+
+	return verdict;
+
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderRecordPause::DoTestStepPostambleL(void)
+	{
+	//delete the output file
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderRecordPause::MoscoStateChangeEvent(CBase* aObject,
+														  TInt /*aPreviousState*/,
+														  TInt /*aCurrentState*/,
+														  TInt aErrorCode)
+	{
+	if (aObject != REINTERPRET_CAST(CBase*, KTestPointerValue))
+		iError = KErrArgument;
+	else
+		iError = aErrorCode;
+	CActiveScheduler::Stop();
+	}
+
+
+// this can return a TBool hasPlayed to prove that it has played
+// but the EPlaying state seems to get preserved for some reason...
+void CTestStepRecorderRecordPause::RecordAndStartSchedulerL()
+	{
+	iRecorder->RecordL();
+	CActiveScheduler::Start();
+	// record 2 secs, ...probably silence
+	User::After(10000000);
+
+	// Stop the recording
+	iRecorder->Stop();
+	User::After(2000000);
+	iRecorder->RecordL();
+
+	User::After(10000000);
+
+
+	if (iRecorder->State() == CMdaAudioRecorderUtility::ERecording)
+		iHasRecorded = ETrue;
+	iRecorder->Stop();
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepRecorderRecordPause::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+    TInt err       = KErrNone;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	/*
+	// record AU file //
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName2);
+	CActiveScheduler::Start();
+	if (iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()*.75);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+
+	// record RAW file //
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName3);
+	CActiveScheduler::Start();
+	if (iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	iRecorder->SetGain(iRecorder->MaxGain()*.75);
+	iRecorder->SetPosition(*iBeginning);
+	iRecorder->CropL();
+
+	if ( iError != KErrNone ||
+		 iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	TRAP( err, RecordAndStartSchedulerL() );
+
+	// check result
+	if (iError != KErrNone ||
+		err != KErrNone ||
+		!iHasRecorded ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EFail;
+
+	iHasRecorded = EFalse;
+	iRecorder->Close();
+	delete iRecorder;
+	iRecorder = NULL;
+	*/
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderError.
+ *
+ *
+ * @return	"CTestStepRecorderError*"
+ *			The constructed CTestStepRecorderError
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderError* CTestStepRecorderError::NewL()
+	{
+	CTestStepRecorderError* self = new(ELeave) CTestStepRecorderError;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(); // self
+	return self;
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderError.
+ *
+ *
+ * @return	"CTestStepRecorderError*"
+ *			The constructed CTestStepRecorderError
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderError::ConstructL()
+	{
+     //[ lets initialise the dispatch table
+	 //with a default method for now ]
+	ASSERT( TestStateTerminal < KMaxMethods );
+
+	 iStates[TestStateIdle]		= &CTestStepRecorderError::IdleStateChangeEventL;
+	 iStates[TestStateOne]		= &CTestStepRecorderError::StateOneChangeEventL;
+	 iStates[TestStateTwo]		= &CTestStepRecorderError::StateTwoChangeEventL;
+	 iStates[TestStateThree]	= &CTestStepRecorderError::StateThreeChangeEventL;
+	 iStates[TestStateFour]		= &CTestStepRecorderError::StateFourChangeEventL;
+	 iStates[TestStateTerminal]	= &CTestStepRecorderError::StateTerminalChangeEventL;
+
+	 //[ set the initial state to idle ]
+	 iTestState = TestStateIdle;
+	}
+
+/**
+ * Enters here as iRecorder goes from ENotReady to EOpen
+ *
+ * Set the priority of iRecorder to EMdaPriorityMin
+ * Set the parent of iRecorderHighPriority to be KTestPointerRecorder2 so we can distinguish state changes
+ *
+ * Next state TestStateOne
+ */
+void CTestStepRecorderError::IdleStateChangeEventL(CBase* aObject,
+												  TInt aPreviousState,
+												  TInt aCurrentState,
+												  TInt aErrorCode )
+	{
+	//[ precondition the state is valid ]
+	ASSERT(IsValidState() );
+
+	//This is state change from iRecorder
+	if(REINTERPRET_CAST(void*,aObject) != REINTERPRET_CAST(void*,KTestPointerRecorder1))
+		{
+		INFO_PRINTF2( _L("IdleStateChangeEventL error from wrong object 0x%x"), aObject);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	//Correct state change
+	if((aPreviousState != CMdaAudioClipUtility::ENotReady) ||
+		(aCurrentState != CMdaAudioClipUtility::EOpen))
+		{
+		INFO_PRINTF1( _L("IdleStateChangeEventL incorrect state change"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+	//[fail if there was an error]
+	if(aErrorCode != KErrNone)
+		{
+		INFO_PRINTF2( _L("IdleStateChangeEventL error %d"),aErrorCode);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioRecord2"), iFileName2))
+		{
+		INFO_PRINTF1( _L("IdleStateChangeEventL couldn't get filename from config  AudioRecord2"));
+		iTestStepResult = EInconclusive;
+		CActiveScheduler::Stop();
+		}
+
+
+	if (SetAudRecorderParent(iRecorderHighPriority, REINTERPRET_CAST(CMdaAudioRecorderUtility*,KTestPointerRecorder2 )) != KErrNone)
+		{
+		INFO_PRINTF1( _L("IdleStateChangeEventL failed to set parent"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+	//[ open the second recorder and update state ]
+	// open an existing file to record and crop all its contents if any
+	iRecorderHighPriority->OpenFileL(iFileName2);
+
+	//[lets do some configuration on the first recorder]
+	iRecorder->SetGain(iRecorder->MaxGain()/2);
+	iRecorder->SetPriority( EMdaPriorityMin, EMdaPriorityPreferenceNone );
+	iRecorder->SetPosition(TTimeIntervalMicroSeconds(0));
+
+	//[ update the state ]
+	TestState newState = TestStateOne;
+	SetState( newState );
+
+	//[ post condition state is valid ]
+	ASSERT(IsValidState() );
+	}
+
+/**
+ * Enters here as iRecorderHighPriority goes from ENotReady to EOpen
+ *
+ * Set the priority of iRecorderHighPriority to EMdaPriorityMax
+ * Start recording to iRecorder
+ *
+ * Next state TestStateTwo
+ *
+ */
+void CTestStepRecorderError::StateOneChangeEventL(CBase* aObject,
+												  TInt aPreviousState,
+												  TInt aCurrentState,
+												  TInt aErrorCode )
+	{
+	//[ precondition state is valid ]
+	ASSERT( IsValidState() );
+
+	//[fail if there was an error]
+	if(aErrorCode != KErrNone)
+		{
+		INFO_PRINTF2( _L("StateOneChangeEventL error %d"),aErrorCode);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+	//This is state change from iRecorderHighPriority
+	if(REINTERPRET_CAST(void*,aObject) != REINTERPRET_CAST(void*,KTestPointerRecorder2))
+		{
+		INFO_PRINTF2( _L("StateOneChangeEventL error from wrong object 0x%x"), aObject);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	//Correct state change
+	if((aPreviousState != CMdaAudioClipUtility::ENotReady) ||
+		(aCurrentState != CMdaAudioClipUtility::EOpen))
+		{
+		INFO_PRINTF1( _L("StateOneChangeEventL incorrect state change"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+
+
+	//[ start recording with recorder 1]
+	iRecorder->RecordL();
+	User::After(2500000);
+
+	//[lets do some configuration on the first recorder]
+	iRecorderHighPriority->SetGain(iRecorder->MaxGain()/2);
+	iRecorderHighPriority->SetPriority( EMdaPriorityMax, EMdaPriorityPreferenceNone );
+	iRecorderHighPriority->SetPosition(TTimeIntervalMicroSeconds(0));
+
+	TestState newState = TestStateTwo;
+	//[ update the state ]
+	SetState(newState);
+
+	//[ post condition state is valid ]
+	ASSERT( IsValidState() );
+	}
+
+/**
+ *
+ * Enters here as iRecorder goes from EOpen to ERecording
+ *
+ * Start recording to iRecorderHighPriority
+ *
+ * Next state TestStateThree
+ *
+ */
+void CTestStepRecorderError::StateTwoChangeEventL(CBase* aObject,
+												  TInt aPreviousState,
+												  TInt aCurrentState,
+												  TInt aErrorCode )
+	{
+	//[ precondition state is valid ]
+	ASSERT( IsValidState() );
+
+	//[fail if there was an error]
+	if(aErrorCode != KErrNone)
+		{
+		INFO_PRINTF2( _L("StateTwoChangeEventL error %d"),aErrorCode);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	//This is state change from iRecorder
+	if(REINTERPRET_CAST(void*,aObject) != REINTERPRET_CAST(void*,KTestPointerRecorder1))
+		{
+		INFO_PRINTF2( _L("StateTwoChangeEventL error from wrong object 0x%x"), aObject);
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	//Correct state change
+	if((aPreviousState != CMdaAudioClipUtility::EOpen) ||
+		(aCurrentState != CMdaAudioClipUtility::ERecording))
+		{
+		INFO_PRINTF1( _L("StateTwoChangeEventL incorrect state change"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+
+	//[ start recording with recorder 1]
+	iRecorderHighPriority->RecordL();
+
+	//[ update state ]
+	TestState newState = TestStateThree;
+	SetState(newState);
+
+	//[ post condition state is valid ]
+	ASSERT( IsValidState() );
+	}
+
+/**
+ * Enters here because of two reasons:-
+ *
+ * 1. iRecorder goes from ERecording to EOpen as it has been thrown off by
+ *    iRecorderHighPriority starting to record
+ *
+ *    aErrorCode == KErrInUse
+ *
+ * 2. iRecorderHighPriority goes from EOpen to ERecording
+ *    aErrorCode == KErrNone
+ *
+ *
+ * Next state TestStateTerminal
+ *
+ */
+void CTestStepRecorderError::StateThreeChangeEventL(CBase* aObject,
+												  TInt aPreviousState,
+												  TInt aCurrentState,
+												  TInt aErrorCode )
+	{
+     //[does nothing for now ]
+	 //[ precondition state is valid ]
+	 ASSERT( IsValidState() );
+
+
+	 //This is a state change from iRecorder
+	if(REINTERPRET_CAST(void*,aObject) == REINTERPRET_CAST(void*,KTestPointerRecorder1))
+		{
+		 if( aErrorCode != KErrInUse )
+			{
+ 			INFO_PRINTF2( _L("StateThreeChangeEventL incorrect error received %d"), aErrorCode);
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+
+		//Correct state change
+		if((aPreviousState != CMdaAudioClipUtility::ERecording) ||
+			(aCurrentState != CMdaAudioClipUtility::EOpen))
+			{
+			INFO_PRINTF1( _L("StateThreeChangeEventL incorrect state change"));
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+		}
+	//This is a state change from iRecorderHighPriority
+	else if(REINTERPRET_CAST(void*,aObject) == REINTERPRET_CAST(void*,KTestPointerRecorder2))
+		{
+		//Correct state change
+		if((aPreviousState != CMdaAudioClipUtility::EOpen) ||
+			(aCurrentState != CMdaAudioClipUtility::ERecording))
+			{
+			INFO_PRINTF1( _L("StateThreeChangeEventL incorrect state change"));
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+		}
+	else
+		{
+		INFO_PRINTF1( _L("StateThreeChangeEventL state change from unknown object"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+
+	 //[Set state]
+	 TestState newState = TestStateTerminal;
+	 SetState(newState);
+
+	//[ post condition state is valid ]
+	ASSERT( IsValidState() );
+	}
+
+/**
+ * Un used state
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderError::StateFourChangeEventL(CBase* /*aObject*/,
+												  TInt /*aPreviousState*/,
+												  TInt /*aCurrentState*/,
+												  TInt /*aErrorCode*/ )
+	{
+    //[ precondition state is valid ]
+	ASSERT( IsValidState() );
+
+
+	//[Update next State]
+	TestState newState = TestStateTerminal;
+	SetState(newState);
+
+	//[ post condition state is valid ]
+	ASSERT( IsValidState() );
+	}
+
+
+/**
+ * Enters here because of two reasons:-
+ *
+ * 1. iRecorder goes from ERecording to EOpen as it has been thrown off by
+ *    iRecorderHighPriority starting to record
+ *
+ *    aErrorCode == KErrInUse
+ *
+ * 2. iRecorderHighPriority goes from EOpen to ERecording
+ *    aErrorCode == KErrNone
+ *
+ * Which one is the other to that which occured in StateThreeChangeEventL
+ * as there is a possible race condition on which event we receive first
+ *
+ */
+void CTestStepRecorderError::StateTerminalChangeEventL(CBase* aObject,
+												  TInt aPreviousState,
+												  TInt aCurrentState,
+												  TInt aErrorCode )
+	{
+	 //[ pre condition state is valid ]
+	 ASSERT( IsValidState() );
+
+	 //This is a state change from iRecorder
+	if(REINTERPRET_CAST(void*,aObject) == REINTERPRET_CAST(void*,KTestPointerRecorder1))
+		{
+		 if( aErrorCode != KErrInUse )
+			{
+ 			INFO_PRINTF2( _L("StateTerminalChangeEventL incorrect error received %d"), aErrorCode);
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+
+		//Correct state change
+		if((aPreviousState != CMdaAudioClipUtility::ERecording) ||
+			(aCurrentState != CMdaAudioClipUtility::EOpen))
+			{
+			INFO_PRINTF1( _L("StateTerminalChangeEventL incorrect state change"));
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+		}
+	//This is a state change from iRecorderHighPriority
+	else if(REINTERPRET_CAST(void*,aObject) == REINTERPRET_CAST(void*,KTestPointerRecorder2))
+		{
+		//Correct state change
+		if((aPreviousState != CMdaAudioClipUtility::EOpen) ||
+			(aCurrentState != CMdaAudioClipUtility::ERecording))
+			{
+			INFO_PRINTF1( _L("StateTerminalChangeEventL incorrect state change"));
+			iTestStepResult = EFail;
+			CActiveScheduler::Stop();
+			}
+		}
+	else
+		{
+		INFO_PRINTF1( _L("StateTerminalChangeEventL state change from unknown object"));
+		iTestStepResult = EFail;
+		CActiveScheduler::Stop();
+		}
+
+	//[ stop recording with recorder 1]
+	INFO_PRINTF1( _L("Stopping iRecorderHighPriority"));
+
+	iRecorderHighPriority->Stop();
+
+	INFO_PRINTF1( _L("iRecorderHighPriority stopped"));
+
+
+	CActiveScheduler::Stop();
+
+	 //[ post condition state is valid ]
+	 ASSERT( IsValidState() );
+	}
+
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderError::PrintState(CBase* aObject,
+										TInt aPreviousState,
+										TInt aCurrentState,
+										TInt aErrorCode )
+{
+ INFO_PRINTF6( _L("Object %x aPrevState %d CurrentState %d, ErrorCode %d FsmState %d"), aObject, aPreviousState, aCurrentState, aErrorCode, iTestState );
+}
+
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+TBool CTestStepRecorderError::IsValidState() const
+	{
+	// provide implementation here
+    TBool result = ETrue;
+    if( (iTestState < TestStateIdle ) || ( iTestState > TestStateTerminal ) )
+		{
+         result = EFalse;
+		}
+	return result;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+ CTestStepRecorderError::TestState CTestStepRecorderError::GetTestState() const
+	{
+	 return iTestState;
+	}
+
+ /**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderError::SetState( CTestStepRecorderError::TestState& aState )
+	{
+	iTestState = aState ;
+	}
+
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderError::CTestStepRecorderError() : iError(0), iHasRecorded(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-0014-CP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderError::~CTestStepRecorderError()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderError::DoTestStepPreambleL(void)
+	{
+
+	enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderError::DoTestStepPostambleL(void)
+	{
+	//delete the output file
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+
+	delete iRecorderHighPriority;
+	iRecorderHighPriority = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderError::MoscoStateChangeEvent(CBase* aObject,
+														  TInt aPreviousState,
+														  TInt aCurrentState,
+														  TInt aErrorcCode)
+	{
+	//[ precondition state is valid ]
+	ASSERT( IsValidState());
+
+	//[ print incoming state ]
+	PrintState( aObject, aPreviousState, aCurrentState, aErrorcCode );
+
+	INFO_PRINTF2(_L("Dispatching into state %d"), iTestState);
+
+
+	//dispatch the reponse
+    (this->*iStates[iTestState])( aObject, aPreviousState, aCurrentState, aErrorcCode );
+
+	//[ post condition state is valid ]
+	ASSERT( IsValidState());
+	}
+
+/**
+*
+* IsValidTestState()
+*
+*/
+
+
+// this can return a TBool hasPlayed to prove that it has played
+// but the EPlaying state seems to get preserved for some reason...
+void CTestStepRecorderError::RecordAndStartSchedulerL()
+	{
+	//[ This method has been deprecated ]
+     ASSERT(0);
+	}
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ *
+ */
+
+TInt aFunction(TAny* /*aPtr*/)
+{
+ return 0;
+}
+
+TVerdict CTestStepRecorderError::DoTestStepL()
+	{
+	//[temporary contruction to test the fsm ]
+	iTestStepResult = EPass;
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0014-CP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility on error"));
+
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	if ( (iRecorderHighPriority = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return  EInconclusive;
+
+	//[ copy files from back up file ]
+	//[ ensure files do not exist ]
+	iFs.Connect();
+	CFileMan* fileMan = CFileMan::NewL(iFs);
+	CleanupStack::PushL(fileMan);
+
+    fileMan->Delete( KTestRecordTwo );
+	fileMan->Delete( KTestRecordOne );
+	User::LeaveIfError(fileMan->Copy( KTestRecordThree, KTestRecordTwo ));
+	User::LeaveIfError(fileMan->Copy( KTestRecordThree, KTestRecordOne ));
+	CleanupStack::PopAndDestroy(fileMan);
+
+	//set up file name
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioRecord1"), iFileName))
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*,KTestPointerRecorder1 )) != KErrNone)
+		return EInconclusive;; // check value in MoscoStateChangeEvent
+
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+
+	//[ if we got here we are ok ]
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+
+/**
+ *
+ * Static constructor for CTestStepRecorderMaxWriteLength.
+ *
+ *
+ * @return	"CTestStepRecorderMaxWriteLength*"
+ *			The constructed CTestStepRecorderMaxWriteLength
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderMaxWriteLength* CTestStepRecorderMaxWriteLength::NewL()
+	{
+	CTestStepRecorderMaxWriteLength* self = new(ELeave) CTestStepRecorderMaxWriteLength;
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderMaxWriteLength::CTestStepRecorderMaxWriteLength() : iError(0)
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0290-HP");
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepRecorderMaxWriteLength::~CTestStepRecorderMaxWriteLength()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderMaxWriteLength::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict = EPass;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0290-HP"));
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::SetMaxWriteLength with argument = -1"));
+
+	// set the file name to something weird
+    iFileName.Set( _L("c:\\szhgefdsfe.wav"));
+
+	//[ ensure the file does not exist]
+	
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		verdict = EInconclusive;
+
+	if (SetAudRecorderParent(iRecorder, REINTERPRET_CAST(CMdaAudioRecorderUtility*, KTestPointerValue)) != KErrNone)
+		return EFail; // check value in MoscoStateChangeEvent
+
+	// open an existing file to record and crop all its contents if any
+	iRecorder->OpenFileL(iFileName);
+	CActiveScheduler::Start();
+	if (iError)
+		{
+		INFO_PRINTF2(_L("open returned %d"), iError);
+		return EFail;
+		}
+
+	if (iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+
+	// if it gets here "-1" is accepted
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepRecorderMaxWriteLength::DoTestStepPostambleL(void)
+	{
+	//delete the output file
+	CFileMan* fileMan;
+	iFs.Connect();
+	fileMan = CFileMan::NewL(iFs);
+	fileMan->Delete(iFileName);
+	iFs.Close();
+	delete fileMan;
+	fileMan = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ *
+ */
+void CTestStepRecorderMaxWriteLength::MoscoStateChangeEvent(CBase* /*aObject*/,
+														  TInt /*aPreviousState*/,
+														  TInt /*aCurrentState*/,
+														  TInt /*aErrorCode*/)
+	{
+	CActiveScheduler::Stop();
+	}
+
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return	"TVerdict"
+ *			The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepRecorderMaxWriteLength::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+
+	// set some limit on bytes to record
+	iRecorder->SetMaxWriteLength(10024);
+	
+	// reset the record limit. 
+	// This is the function WHICH is being tested
+	iRecorder->SetMaxWriteLength(-1); 
+		
+	iRecorder->Close();
+	
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+#ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
+	_LIT(KRecorderThread1,"RecorderThread1");
+	_LIT(KRecorderThread2,"RecorderThread2");
+	_LIT(KRecorderThread3,"RecorderThread3");
+	const TInt KDefaultHeapSize=0x100000;
+#endif	
+
+// factory function
+CRecordAudio* CRecordAudio::NewL()
+	{
+	CRecordAudio* self = new (ELeave) CRecordAudio();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+// Destructor
+CRecordAudio::~CRecordAudio()
+	{
+	if (iUtility)
+		{
+		// if it exists, always stop the utility - null action if not running
+		iUtility->Stop();
+		delete iUtility;
+		}
+	}
+
+// 2nd phase constructor
+void CRecordAudio::ConstructL()
+	{
+	iUtility = CMdaAudioRecorderUtility::NewL(*this);
+	iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+	}
+	
+// constructor
+CRecordAudio::CRecordAudio()
+	{
+	}
+	
+void CRecordAudio::RecordL(const TDesC& aFileName, TInt aPriority)
+	{
+	// Note: in this scenario, the calling code can handle the leave here
+	// but alternatively we would have to trap and (using one-shot AO) arrange
+	// for the callback to be subsequently called.
+	iUtility->SetPriority(aPriority, EMdaPriorityPreferenceNone);
+	iUtility->OpenFileL(aFileName); 
+	}
+	
+void CRecordAudio::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
+	{
+	__ASSERT_DEBUG(aObject==iUtility, User::Invariant());
+	aObject = aObject; // shutup warning
+	
+	iError = aErrorCode;
+	
+	if (iError==KErrNone)
+		{
+		// only interested in some state transitions...
+		if (aPreviousState==CMdaAudioRecorderUtility::ENotReady && 
+		        aCurrentState==CMdaAudioRecorderUtility::EOpen)
+			{
+			// have opened the file
+			iUtility->RecordL();
+			}
+		else if (aPreviousState==CMdaAudioRecorderUtility::EOpen && 
+		         aCurrentState==CMdaAudioRecorderUtility::ERecording)
+			{
+			//start a timer
+			TCallBack callback (TimerCallback, this);
+			const TInt KWaitTime = 2000000; // 2s
+			iTimer->Start(KWaitTime, 0, callback);
+			}
+		}
+	else
+		{
+		if (aPreviousState==CMdaAudioRecorderUtility::ERecording && 
+		    aCurrentState==CMdaAudioRecorderUtility::EOpen)
+			{
+			iTimer->Cancel();
+			CActiveScheduler::Stop();
+			}
+		}
+	}
+
+// having opened the file, give settings and then start to record
+void CRecordAudio::OnOpenL()
+	{
+	iUtility->RecordL();
+	}
+
+// timer callback
+TInt CRecordAudio::TimerCallback(TAny* aPtr)
+	{
+	static_cast<CRecordAudio*>(aPtr)->DoTimerCallback();
+	return KErrNone;
+	}
+
+void CRecordAudio::DoTimerCallback()
+	{
+	iTimer->Cancel(); // only really wanted a one-shot
+	iUtility->Stop();
+	CActiveScheduler::Stop();
+	}
+	
+RAudioConcurrentRecTest* RAudioConcurrentRecTest::NewL(const TDesC& aStepName, TInt aRecPriority1, TInt aRecPriority2, TInt aRecPriority3)
+	{
+	RAudioConcurrentRecTest* self = new (ELeave) RAudioConcurrentRecTest(aStepName, aRecPriority1, aRecPriority2, aRecPriority3);
+	return self;
+	}
+	
+RAudioConcurrentRecTest::RAudioConcurrentRecTest(const TDesC& aStepName, TInt aRecPriority1, TInt aRecPriority2, TInt aRecPriority3)
+	:iRecPriority1(aRecPriority1), iRecPriority2(aRecPriority2), iRecPriority3(aRecPriority3) 
+	{
+	iTestStepName = aStepName; 
+	}
+
+TInt StartThreadL(TAny* aData)
+	{
+	TInt* priority = static_cast<TInt*> (aData);
+	// Create active scheduler (to run active objects)
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
+	CleanupStack::PushL(scheduler);
+	CActiveScheduler::Install(scheduler);
+	
+	CRecordAudio* recorder = CRecordAudio::NewL();
+	CleanupStack::PushL(recorder);
+	
+	TBuf<50> fileName;
+	fileName.Append(_L("c:\\"));
+	fileName.Append(RThread().Name());
+	fileName.Append(_L(".wav"));
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	fs.Delete(fileName); // ensure we start with no file. Ignore errors.
+		
+	recorder->RecordL(fileName, *priority);
+	CActiveScheduler::Start();
+	fs.Delete(fileName); // ensure we start with no file. Ignore errors.
+	TInt err = recorder->Error();
+	CleanupStack::PopAndDestroy(3,scheduler);
+	return err;
+	}
+	
+TInt StartThread(TAny* aData)
+	{
+	CTrapCleanup* cleanup = CTrapCleanup::New();	
+	TInt result=KErrNone;
+	TRAPD(error, result = StartThreadL(aData));
+	delete cleanup;
+	if(error)
+		{
+		return error;
+		}
+	else if(result)
+		{
+		return result;
+		}
+	else
+		{
+		return KErrNone;
+		}	
+	}
+
+// start test
+void RAudioConcurrentRecTest::KickoffTestL()
+	{
+	INFO_PRINTF1( _L("DEF121928:This test creates three threads and starts recording concurrently from all the three threads"));
+	INFO_PRINTF4( _L("RecorderUtility1 has Priority[%d] RecorderUtility2 has Priority[%d] RecorderUtility3 has Priority[%d]"), iRecPriority1, iRecPriority2, iRecPriority3);
+	
+	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
+		INFO_PRINTF1( _L("This test is only for A3F: Just making it pass without testing on old devsound"));
+		StopTest(KErrNone);
+	#else
+		User::LeaveIfError(iThread1.Create(KRecorderThread1, StartThread, KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &iRecPriority1));
+	    User::LeaveIfError(iThread2.Create(KRecorderThread2, StartThread, KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &iRecPriority2));
+	    User::LeaveIfError(iThread3.Create(KRecorderThread3, StartThread, KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &iRecPriority3));
+		
+		TRequestStatus status1;
+	    TRequestStatus status2;
+	    TRequestStatus status3;
+	    iThread1.Logon(status1);
+	    iThread2.Logon(status2);
+	    iThread3.Logon(status3);
+	    iThread1.Resume();
+	    iThread2.Resume();
+	    iThread3.Resume();
+		User::WaitForRequest(status1);
+	    User::WaitForRequest(status2);
+	    User::WaitForRequest(status3);
+	    
+	    INFO_PRINTF2( _L("Thread1 is terminated with error[%d]"), status1.Int());
+	    INFO_PRINTF2( _L("Thread2 is terminated with error[%d]"), status2.Int());
+	    INFO_PRINTF2( _L("Thread3 is terminated with error[%d]"), status3.Int());
+	    
+	    TVerdict result = EPass;
+	    //Check first that the thread with the max priority is successful
+	   	if(status1.Int() != KErrNone && iRecPriority1 == EMdaPriorityMax)
+	   		{
+	   		INFO_PRINTF1( _L("Thread1 has failed to record inspite of having EMdaPriorityMax"));
+	   		result = EFail;
+	   		}
+	   	if(status2.Int() != KErrNone && iRecPriority2 == EMdaPriorityMax)
+	   		{
+	   		INFO_PRINTF1( _L("Thread2 has failed to record inspite of having EMdaPriorityMax"));
+	   		result = EFail;
+	   		}
+	   	if(status3.Int() != KErrNone && iRecPriority3 == EMdaPriorityMax)
+	   		{
+	   		INFO_PRINTF1( _L("Thread3 has failed to record inspite of having EMdaPriorityMax"));
+	   		result = EFail;
+	   		}
+	   	//Check if the lower priority gets the KErrInUse
+	   	if(status1.Int()!= KErrInUse && (iRecPriority1== EMdaPriorityMin || iRecPriority1== EMdaPriorityNormal))
+			{
+			INFO_PRINTF1( _L("Thread1 has failed to receive KErrInUse inspite of having EMdaPriorityMin or EMdaPriorityNormal"));
+	   		result = EFail;
+			}
+		if(status2.Int()!= KErrInUse && (iRecPriority2== EMdaPriorityMin || iRecPriority2== EMdaPriorityNormal))
+			{
+			INFO_PRINTF1( _L("Thread2 has failed to receive KErrInUse inspite of having EMdaPriorityMin or EMdaPriorityNormal"));
+	   		result = EFail;
+			}
+		if(status3.Int()!= KErrInUse && (iRecPriority3== EMdaPriorityMin || iRecPriority3== EMdaPriorityNormal))
+			{
+			INFO_PRINTF1( _L("Thread1 has failed to receive KErrInUse inspite of having EMdaPriorityMin or EMdaPriorityNormal"));
+	   		result = EFail;
+			}
+		StopTest(KErrNone, result);
+	#endif
+	}
+	
+// cleanup at end
+void RAudioConcurrentRecTest::CloseTest()
+	{
+	iThread1.Close();
+    iThread2.Close();
+    iThread3.Close();
+	}
+
+// factory function
+CRecorder* CRecorder::NewL(MRecordAudioObserver* aObserver)
+	{
+	CRecorder* self = new (ELeave) CRecorder(aObserver);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+// Destructor
+CRecorder::~CRecorder()
+	{
+	if (iUtility)
+		{
+		// if it exists, always stop the utility - null action if not running
+		iUtility->Stop();
+		delete iUtility;
+		}
+	}
+
+// 2nd phase constructor
+void CRecorder::ConstructL()
+	{
+	iUtility = CMdaAudioRecorderUtility::NewL(*this);
+	iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+	}
+	
+// constructor
+CRecorder::CRecorder(MRecordAudioObserver* aObserver)
+	:iObserver(aObserver)
+	{
+	}
+	
+void CRecorder::RecordL(const TDesC& aFileName, TInt aPriority)
+	{
+	iUtility->SetPriority(aPriority, EMdaPriorityPreferenceNone);
+	const TUid KPanicControllerUid = {0x10286661};
+	iUtility->OpenFileL(aFileName, KPanicControllerUid);
+	}
+	
+void CRecorder::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
+	{
+	__ASSERT_DEBUG(aObject==iUtility, User::Invariant());
+	aObject = aObject; // shutup warning
+	
+	iError = aErrorCode;
+	
+	if (iError==KErrNone)
+		{
+		// only interested in some state transitions...
+		if (aPreviousState==CMdaAudioRecorderUtility::ENotReady && 
+		        aCurrentState==CMdaAudioRecorderUtility::EOpen)
+			{
+			// have opened the file
+			iUtility->RecordL();
+			}
+		else if (aPreviousState==CMdaAudioRecorderUtility::EOpen && 
+		         aCurrentState==CMdaAudioRecorderUtility::ERecording)
+			{
+			//start a timer
+			TCallBack callback (TimerCallback, this);
+			const TInt KWaitTime = 2000000; // 2s
+			iTimer->Start(KWaitTime, 0, callback);
+			}
+		}
+	else
+		{
+		if (aPreviousState==CMdaAudioRecorderUtility::ERecording && 
+		    aCurrentState==CMdaAudioRecorderUtility::EOpen)
+			{
+			iTimer->Cancel();
+			}
+		iObserver->RecordError(iError);
+		}
+	}
+
+// having opened the file, give settings and then start to record
+void CRecorder::OnOpenL()
+	{
+	iUtility->RecordL();
+	}
+
+// timer callback
+TInt CRecorder::TimerCallback(TAny* aPtr)
+	{
+	static_cast<CRecorder*>(aPtr)->DoTimerCallback();
+	return KErrNone;
+	}
+
+void CRecorder::DoTimerCallback()
+	{
+	iTimer->Cancel(); // only really wanted a one-shot
+	iUtility->Stop();
+	iObserver->RecordError(KErrNone);
+	}
+
+RAudioRecPanicTest* RAudioRecPanicTest::NewL(const TDesC& aStepName, const TDesC& aFileName)
+	{
+	RAudioRecPanicTest* self = new (ELeave) RAudioRecPanicTest(aStepName, aFileName);
+	return self;
+	}
+	
+RAudioRecPanicTest::RAudioRecPanicTest(const TDesC& aStepName, const TDesC& aFileName) :
+	iRecorder(NULL),
+	iFileName (aFileName)
+	{
+	iTestStepName = aStepName;
+	}
+	
+// start test
+void RAudioRecPanicTest::KickoffTestL()
+	{
+	INFO_PRINTF1(_L("DEF127630:Fix for INC108007 appears to close "));
+	// re-initialise data - orphan any pointer, as would relate to
+	// previous run's heap
+	iRecorder = NULL; 
+	
+	User::LeaveIfError(iFs.Connect());
+	iFs.Delete(iFileName); // ensure we start with no file. Ignore errors.
+	
+	iRecorder = CRecorder::NewL(this);
+	iSuite->Log(ESevrInfo, _L("Recording Started...."));
+	iRecorder->RecordL(iFileName, EMdaPriorityNormal);
+	}
+	
+// cleanup at end
+void RAudioRecPanicTest::CloseTest()
+	{
+	delete iRecorder;
+	iRecorder = NULL;
+	iFs.Close();
+	}
+	
+// recording stopped
+void RAudioRecPanicTest::RecordError(TInt aError)
+	{
+	iSuite->Log(ESevrInfo, _L("Recording Finished...."));
+	if(aError!=KErrServerTerminated)
+		{
+		StopTest(aError, EFail);
+		}
+	else
+		{
+		StopTest(aError, EPass);
+		}
+	}