--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepRecorderPosPlay.cpp	Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,1050 @@
+// 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>
+// --------------------------------------------
+
+/**
+ *
+ * Static constructor for CTestStepRecorderPosPlay.
+ *
+ *
+ * @return	"CTestStepRecorderPosPlay*"
+ *			The constructed CTestStepRecorderPosPlay
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPosPlay* CTestStepRecorderPosPlay::NewL(const TDesC& aTestName, TBool aIsConverterTest)
+	{
+	CTestStepRecorderPosPlay* self = new(ELeave) CTestStepRecorderPosPlay(aTestName, aIsConverterTest);
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPosPlay::CTestStepRecorderPosPlay(const TDesC& aTestName, TBool aIsConverterTest)
+: iIsConverterTest(aIsConverterTest)
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = aTestName;
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPosPlay::~CTestStepRecorderPosPlay()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPosPlay::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(iTestStepName);
+	if (!iIsConverterTest)
+		{
+		INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::Position()-PlayL()"));
+		}
+	else
+		{
+		INFO_PRINTF1(_L("this is a test of CMdaAudioConvertUtility::Position()-PlayL()"));
+		}
+
+	if(!(GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName7"), iFileName) && // wav
+		 GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToConvert"), iFileName3) // au
+		)) 
+		{
+		//INFO_PRINTF2(_L("file name %s not found..."), fileptr);
+		return EInconclusive;
+		}
+
+	if (!iIsConverterTest)
+		{
+		// create the Recorder utility
+		if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+			return EInconclusive;
+
+		iRecorder->OpenFileL( iFileName );
+		CActiveScheduler::Start(); 
+		if (iRecorder == NULL ||
+			iError != KErrNone ||
+			iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+			return EInconclusive;
+		
+		iMiddle = TTimeIntervalMicroSeconds( iRecorder->Duration().Int64() / 2 );
+		iEnd = iRecorder->Duration();
+		}
+	else
+		{
+		// create the Recorder utility
+		if ( (iConvert = CMdaAudioConvertUtility::NewL(*this)) == NULL )
+			return EInconclusive;
+
+		iConvert->OpenL( iFileName, iFileName3 );
+		CActiveScheduler::Start(); 
+		if (iConvert == NULL ||
+			iError != KErrNone ||
+			iConvert->State() != CMdaAudioConvertUtility::EOpen)
+			return EInconclusive;
+		
+		iMiddle = TTimeIntervalMicroSeconds( iConvert->Duration().Int64() / 2 );
+		iEnd = iConvert->Duration();
+		}
+		
+		iBeginning = TTimeIntervalMicroSeconds( 0 );
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPosPlay::DoTestStepPostambleL(void)
+	{
+	iFs.Connect();
+	iFileMan = CFileMan::NewL(iFs);
+	iFileMan->Delete(iFileName3);
+	iFs.Close();
+	delete iFileMan;
+	iFileMan = NULL;
+	if (!iIsConverterTest)
+		{
+		delete iRecorder;
+		iRecorder = NULL;
+		}
+	else
+		{
+		delete iConvert;
+		iConvert = NULL;
+		}
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ * 
+ */
+void CTestStepRecorderPosPlay::MoscoStateChangeEvent(CBase* /*aObject*/,
+														  TInt /*aPreviousState*/,
+														  TInt /*aCurrentState*/,
+														  TInt aErrorcCode)
+	{
+	iError = aErrorcCode;
+	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 CTestStepRecorderPosPlay::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+
+	if (!iIsConverterTest)
+		{
+		iRecorder->SetPosition(iMiddle);
+		if (iRecorder->Position() != iMiddle )
+			return EFail;
+
+		iRecorder->SetPosition(iBeginning);
+		if (iRecorder->Position() != iBeginning )
+			return EFail;
+
+		iRecorder->SetPosition(iEnd);
+		if (iRecorder->Position() != iEnd )
+			return EFail;
+
+		iRecorder->SetPosition(TTimeIntervalMicroSeconds(1));
+		if (iRecorder->Position() != TTimeIntervalMicroSeconds(1) )
+			return EFail;
+
+		iRecorder->SetPosition(TTimeIntervalMicroSeconds(1000));
+		if (iRecorder->Position() != TTimeIntervalMicroSeconds(1000) )
+			return EFail;
+
+		iRecorder->SetPosition(TTimeIntervalMicroSeconds(1000000));
+		if (iRecorder->Position() != TTimeIntervalMicroSeconds(1000000) )
+			return EFail;
+		}
+	else // iIsConverterTest == ETrue
+		{
+		iConvert->SetPosition(iMiddle);
+		if (iConvert->Position() != iMiddle )
+			return EFail;
+
+		iConvert->SetPosition(iBeginning);
+		if (iConvert->Position() != iBeginning )
+			return EFail;
+
+		iConvert->SetPosition(iEnd);
+		if (iConvert->Position() != iEnd )
+			return EFail;
+
+		iConvert->SetPosition(TTimeIntervalMicroSeconds(1));
+		if (iConvert->Position() != TTimeIntervalMicroSeconds(1) )
+			return EFail;
+
+		iConvert->SetPosition(TTimeIntervalMicroSeconds(1000));
+		if (iConvert->Position() != TTimeIntervalMicroSeconds(1000) )
+			return EFail;
+
+		iConvert->SetPosition(TTimeIntervalMicroSeconds(1000000));
+		if (iConvert->Position() != TTimeIntervalMicroSeconds(1000000) )
+			return EFail;
+		}
+
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderPlayFF.
+ *
+ *
+ * @return	"CTestStepRecorderPlayFF*"
+ *			The constructed CTestStepRecorderPlayFF
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayFF* CTestStepRecorderPlayFF::NewL(const TDesC& aTestName)
+	{
+	CTestStepRecorderPlayFF* self = new(ELeave) CTestStepRecorderPlayFF(aTestName);
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayFF::CTestStepRecorderPlayFF(const TDesC& aTestName)
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = aTestName;
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayFF::~CTestStepRecorderPlayFF()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPlayFF::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(iTestStepName);
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility::PlayL(), Rewind & Fast forward"));
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName))
+		{
+		INFO_PRINTF2(_L("file name %S not found..."), &iFileName);
+		return EInconclusive;
+		}
+
+	// create the Recorder utility
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	iRecorder->OpenFileL( iFileName );
+	CActiveScheduler::Start(); 
+
+	if (iRecorder == NULL ||
+		iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+	
+	// initialize a callback timer
+	TRAPD(err, iTimer = CCallbackTimer::NewL(*this));
+	if (err != KErrNone)
+		return EInconclusive;
+	CActiveScheduler::Add(iTimer);
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPlayFF::DoTestStepPostambleL(void)
+	{
+	delete iTimer;
+	iTimer = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ * 
+ */
+void CTestStepRecorderPlayFF::MoscoStateChangeEvent(CBase* /*aObject*/,
+														  TInt aPreviousState,
+														  TInt aCurrentState,
+														  TInt aErrorCode)
+	{
+	iState = aCurrentState;
+	iError = aErrorCode;
+
+	INFO_PRINTF3(_L("MoscoStateChangeEvent(): Prev state = %d, current state = %d"), aPreviousState, aCurrentState);
+
+	iSchedulerStopReason = EStateChange;
+	
+	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 CTestStepRecorderPlayFF::DoTestStepL()
+	{
+	const TInt KTenthOfASecond = 100000;
+	const TInt KOneSecond = 1000000;
+	const TInt KMaxRWs = 20;
+	const TInt KMaxFFs = 30;
+	TInt expectedState;
+	
+	iTestStepResult = EPass;
+
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	TTimeIntervalMicroSeconds duration = iRecorder->Duration();
+	INFO_PRINTF2(_L("Duration = %d"), I64INT(duration.Int64()));
+
+	INFO_PRINTF1(_L("Calling PlayL().."));
+	iRecorder->PlayL();
+	CActiveScheduler::Start(); 
+	expectedState = CMdaAudioRecorderUtility::EPlaying;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	INFO_PRINTF1(_L("state = EPlaying.."));
+
+	INFO_PRINTF1(_L("Waiting for half way thru play.."));
+	// wait until we're half way thru play
+	iTimer->After(I64INT(duration.Int64() / 2));
+	CActiveScheduler::Start();
+	INFO_PRINTF1(_L("Finished."));
+
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+
+	INFO_PRINTF1(_L("Rewinding like mad....."));
+	TInt n;
+	for (n=0; n < KMaxRWs && iState == CMdaAudioRecorderUtility::EPlaying && iError == KErrNone; n++)
+		{
+		iSchedulerStopReason = EUnknown;
+		iTimer->After(KTenthOfASecond);
+		CActiveScheduler::Start();
+
+		TTimeIntervalMicroSeconds position = iRecorder->Position();
+		TTimeIntervalMicroSeconds nextPosition = (position.Int64() - KOneSecond);
+		if (nextPosition.Int64() < 0)
+			nextPosition = 0;
+
+		iRecorder->SetPosition(nextPosition);
+		INFO_PRINTF3(_L("Current position = %d, next = %d"), I64INT(position.Int64()), I64INT(iRecorder->Position().Int64()));
+
+		if (iSchedulerStopReason != ETimer)
+			break;
+		}
+	
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	
+
+	INFO_PRINTF1(_L("Waiting for half way thru play.."));
+	// wait until we're half way thru play
+	iTimer->After(I64INT(duration.Int64() / 2));
+	CActiveScheduler::Start();
+	INFO_PRINTF1(_L("Finished."));
+
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+
+	INFO_PRINTF1(_L("Fast forwarding like mad....."));
+	for (n=0; n < KMaxFFs && iState == CMdaAudioRecorderUtility::EPlaying && iError == KErrNone; n++)
+		{
+		iSchedulerStopReason = EUnknown;
+		iTimer->After(KTenthOfASecond);
+		CActiveScheduler::Start();
+
+		TTimeIntervalMicroSeconds position = iRecorder->Position();
+		TTimeIntervalMicroSeconds nextPosition = (position.Int64() + KOneSecond);
+		if (nextPosition.Int64() > duration.Int64())
+			{
+			nextPosition = duration;
+			}
+
+		iRecorder->SetPosition(nextPosition);
+		INFO_PRINTF4(_L("Current position = %d, next = %d, new = %d"), 
+			I64INT(position.Int64()), I64INT(nextPosition.Int64()), I64INT(iRecorder->Position().Int64()));
+
+		if (iSchedulerStopReason != ETimer)
+			break;
+		}
+	
+	INFO_PRINTF1(_L("finished playing.."));
+	
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+
+	INFO_PRINTF1(_L("finished with this test step"));
+
+	return iTestStepResult;
+	}
+
+CTestStepRecorderPlayFF::CCallbackTimer::CCallbackTimer(CTestStepRecorderPlayFF& aTest) 
+	: CTimer(EPriorityNormal), iTest(aTest)
+	{
+	}
+
+CTestStepRecorderPlayFF::CCallbackTimer::~CCallbackTimer()
+	{
+	}
+
+CTestStepRecorderPlayFF::CCallbackTimer* CTestStepRecorderPlayFF::CCallbackTimer::NewL(CTestStepRecorderPlayFF& aTest)
+	{
+	CCallbackTimer* timer = new(ELeave) CCallbackTimer(aTest);
+	CleanupStack::PushL(timer);
+	timer->ConstructL();
+	CleanupStack::Pop(timer);
+	return timer;
+	}
+
+void CTestStepRecorderPlayFF::CCallbackTimer::RunL()
+	{
+	iTest.iSchedulerStopReason = ETimer;
+	CActiveScheduler::Stop();
+	}
+
+
+/**
+ *
+ * Static constructor for CTestStepRecorderPlayEOF.
+ *
+ *
+ * @return	"CTestStepRecorderPlayEOF*"
+ *			The constructed CTestStepRecorderPlayEOF
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayEOF* CTestStepRecorderPlayEOF::NewL(const TDesC& aTestName)
+	{
+	CTestStepRecorderPlayEOF* self = new(ELeave) CTestStepRecorderPlayEOF(aTestName);
+	return self;
+	}
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayEOF::CTestStepRecorderPlayEOF(const TDesC& aTestName)
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = aTestName;
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayEOF::~CTestStepRecorderPlayEOF()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPlayEOF::DoTestStepPreambleL(void)
+	{
+	 enum TVerdict verdict;
+	 // this installs the scheduler
+	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+	// Printing to the console and log file
+	INFO_PRINTF1(iTestStepName);
+	INFO_PRINTF1(_L("this is a test of CMdaAudioRecorderUtility..."));
+	INFO_PRINTF1(_L("Play a clip from the middle to EOF, then set the position to the clip's"));
+	INFO_PRINTF1(_L("duration, call play and then immediately read the position and check it's"));
+	INFO_PRINTF1(_L("not longer than the file's duration"));
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName))
+		{
+		INFO_PRINTF2(_L("file name %S not found..."), &iFileName);
+		return EInconclusive;
+		}
+
+	// create the Recorder utility
+	if ( (iRecorder = CMMFMdaAudioRecorderUtility::NewL(*this)) == NULL )
+		return EInconclusive;
+
+	iRecorder->OpenFileL( iFileName );
+	CActiveScheduler::Start(); 
+
+	if (iRecorder == NULL ||
+		iError != KErrNone ||
+		iRecorder->State() != CMdaAudioRecorderUtility::EOpen)
+		return EInconclusive;
+	
+	// initialize a callback timer
+	TRAPD(err, iTimer = CCallbackTimer::NewL(*this));
+	if (err != KErrNone)
+		return EInconclusive;
+	CActiveScheduler::Add(iTimer);
+
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+enum TVerdict CTestStepRecorderPlayEOF::DoTestStepPostambleL(void)
+	{
+	delete iTimer;
+	iTimer = NULL;
+
+	delete iRecorder;
+	iRecorder = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ * 
+ */
+void CTestStepRecorderPlayEOF::MoscoStateChangeEvent(CBase* /*aObject*/,
+														  TInt aPreviousState,
+														  TInt aCurrentState,
+														  TInt aErrorCode)
+	{
+	iState = aCurrentState;
+	iError = aErrorCode;
+
+	INFO_PRINTF3(_L("MoscoStateChangeEvent(): Prev state = %d, current state = %d"), aPreviousState, aCurrentState);
+
+	iSchedulerStopReason = EStateChange;
+	
+	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 CTestStepRecorderPlayEOF::DoTestStepL()
+	{
+	TInt expectedState;
+	
+	iTestStepResult = EPass;
+
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	TTimeIntervalMicroSeconds duration = iRecorder->Duration();
+	INFO_PRINTF2(_L("Duration = %d"), I64INT(duration.Int64()));
+
+	
+	TTimeIntervalMicroSeconds midPosition = TTimeIntervalMicroSeconds(duration.Int64() / 2);
+	INFO_PRINTF2(_L("Setting position to %d"), I64INT(midPosition.Int64()));
+	iRecorder->SetPosition(midPosition);
+
+	INFO_PRINTF1(_L("Calling PlayL().."));
+	iRecorder->PlayL();
+	CActiveScheduler::Start(); 
+	expectedState = CMdaAudioRecorderUtility::EPlaying;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	INFO_PRINTF1(_L("Waiting for EOF.."));
+	CActiveScheduler::Start(); 
+	INFO_PRINTF1(_L("finished playing.."));
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+	INFO_PRINTF2(_L("Setting position = Duration = %d"), I64INT(duration.Int64()));
+	iRecorder->SetPosition(duration);
+
+	INFO_PRINTF1(_L("Calling PlayL() again.."));
+	iRecorder->PlayL();
+	
+	
+	TTimeIntervalMicroSeconds position = iRecorder->Position();
+	INFO_PRINTF2(_L("Current position = %d"), I64INT(position.Int64()));
+	if (position.Int64() > duration.Int64())
+		{
+		INFO_PRINTF1(_L("Position is longer than the duration"));
+		return EFail;
+		}
+
+
+	CActiveScheduler::Start(); 
+
+	expectedState = CMdaAudioRecorderUtility::EPlaying;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+	INFO_PRINTF1(_L("state = EPlaying.."));
+
+	INFO_PRINTF1(_L("Waiting for EOF.."));
+	CActiveScheduler::Start();
+	INFO_PRINTF1(_L("Finished."));
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+	
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+
+
+//##############################################################
+
+	iRecorder->Stop();
+
+	TTimeIntervalMicroSeconds sillyPosition = 
+		TTimeIntervalMicroSeconds(duration.Int64() + 1000000);
+	INFO_PRINTF2(_L("Setting position past EOF = %d"), I64INT(sillyPosition.Int64()));
+	iRecorder->SetPosition(sillyPosition);
+
+	INFO_PRINTF1(_L("Calling PlayL() again.."));
+	iRecorder->PlayL();
+	
+	
+	position = iRecorder->Position();
+	INFO_PRINTF2(_L("Current position = %d"), I64INT(position.Int64()));
+	if (position.Int64() > duration.Int64())
+		{
+		INFO_PRINTF1(_L("Position is longer than the duration (before play has started - OK)"));
+//		return EFail;
+		}
+
+
+	CActiveScheduler::Start(); 
+
+	expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iState != expectedState && iError != KErrArgument)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iState, iError);
+		return EFail;
+		}
+//##############################################################
+	INFO_PRINTF1(_L("finished with this test step"));
+
+	return iTestStepResult;
+	}
+
+CTestStepRecorderPlayEOF::CCallbackTimer::CCallbackTimer(CTestStepRecorderPlayEOF& aTest) 
+	: CTimer(EPriorityNormal), iTest(aTest)
+	{
+	}
+
+CTestStepRecorderPlayEOF::CCallbackTimer::~CCallbackTimer()
+	{
+	}
+
+CTestStepRecorderPlayEOF::CCallbackTimer* CTestStepRecorderPlayEOF::CCallbackTimer::NewL(CTestStepRecorderPlayEOF& aTest)
+	{
+	CCallbackTimer* timer = new(ELeave) CCallbackTimer(aTest);
+	CleanupStack::PushL(timer);
+	timer->ConstructL();
+	CleanupStack::Pop(timer);
+	return timer;
+	}
+
+void CTestStepRecorderPlayEOF::CCallbackTimer::RunL()
+	{
+	iTest.iSchedulerStopReason = ETimer;
+	CActiveScheduler::Stop();
+	}
+
+/**
+ *
+ * Static constructor for CTestStepRecorderPlayStopPosStop.
+ *
+ *
+ * @return	"CTestStepRecorderPlayStopPosStop*"
+ *			The constructed CTestStepRecorderPlayStopPosStop
+ *
+ * @xxxx
+ * 
+ */
+CTestStepRecorderPlayStopPosStop* CTestStepRecorderPlayStopPosStop::NewL()
+	{
+	CTestStepRecorderPlayStopPosStop* self = new(ELeave) CTestStepRecorderPlayStopPosStop;
+	return self;
+	}
+
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ * 
+ */
+
+CTestStepRecorderPlayStopPosStop::CTestStepRecorderPlayStopPosStop()
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	iTestStepName = _L("MM-MMF-ACLNT-U-0857-HP");
+
+	}
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ * 
+ */
+
+CTestStepRecorderPlayStopPosStop::~CTestStepRecorderPlayStopPosStop()
+	{
+	}
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ * 
+ */
+
+TVerdict CTestStepRecorderPlayStopPosStop::DoTestStepPreambleL(void)
+	{
+	TVerdict verdict=EPass;
+	 // this installs the scheduler
+	if((verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL())	!= EPass)
+		{
+		return EInconclusive;
+		}
+
+	// Printing to the console and log file
+	INFO_PRINTF2(_L("%S"), &iTestStepName);
+	INFO_PRINTF1(_L("this is a test of calling Play, Stop, SetPosition"));
+	INFO_PRINTF1(_L("and then call Stop again & verifying the position is set to the beginning"));
+
+	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName10"), iFileName)) 
+		{
+		return EInconclusive;
+		}
+	// create the Recorder utility
+	TRAPD(error, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this));
+	if (error != KErrNone)
+		{
+		return EInconclusive;
+		}
+	return verdict;
+	}
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ * 
+ */
+TVerdict CTestStepRecorderPlayStopPosStop::DoTestStepPostambleL(void)	
+	{
+	delete iRecorderUtility;
+	iRecorderUtility = NULL;
+
+	//[ Destroy the scheduler ]
+	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+	}
+
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ * 
+ */
+/**
+ *
+ * Callback Handle.
+ *
+ * @xxxx
+ * 
+ */
+void CTestStepRecorderPlayStopPosStop::MoscoStateChangeEvent(CBase* /*aObject*/,
+														  TInt aPreviousState,
+														  TInt aCurrentState,
+														  TInt aErrorCode)
+	{
+	iCurrentState = aCurrentState;
+	iError = aErrorCode;
+
+	INFO_PRINTF3(_L("MoscoStateChangeEvent(): Prev state = %d, current state = %d"), aPreviousState, aCurrentState);
+
+	CActiveScheduler::Stop();
+	}
+
+
+
+TVerdict CTestStepRecorderPlayStopPosStop::DoTestStepL()
+	{
+	iTestStepResult = EPass;
+
+	INFO_PRINTF1(_L("Opening file using player utility..."));
+	
+	// open the sound file
+	TRAP(iError, iRecorderUtility->OpenFileL(iFileName));
+	if (iError != KErrNone)
+		{
+		return EInconclusive;
+		}
+	// wait for open to complete
+	CActiveScheduler::Start(); 
+	
+	TInt expectedState = CMdaAudioRecorderUtility::EOpen;
+	if (iCurrentState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iCurrentState, iError);
+		return EFail;
+		}
+	
+
+	TTimeIntervalMicroSeconds playStart = TTimeIntervalMicroSeconds(0);
+	TTimeIntervalMicroSeconds playEnd = iRecorderUtility->Duration();
+	
+	iRecorderUtility->SetPlayWindow(playStart, playEnd);
+	
+	INFO_PRINTF1(_L("calling play..."));
+	
+	iRecorderUtility->PlayL();
+			
+	CActiveScheduler::Start(); 
+	
+	expectedState = CMdaAudioRecorderUtility::EPlaying;
+	if (iCurrentState != expectedState && iError != KErrNone)
+		{
+		INFO_PRINTF4(_L("Unexpected state; expected = %d, actual = %d, error = %d"), expectedState, iCurrentState, iError);
+		return EFail;
+		}
+	
+	User::After(500000);
+
+	iRecorderUtility->Stop();
+	
+	TTimeIntervalMicroSeconds step = TTimeIntervalMicroSeconds(200000);
+	
+	iRecorderUtility->SetPosition(step);
+
+	iRecorderUtility->Stop();
+
+	TTimeIntervalMicroSeconds position = iRecorderUtility->Position();
+	
+	if (position.Int64() != playStart.Int64())
+		{
+		return EFail;
+		}
+	
+
+	iRecorderUtility->Close();
+	
+	return iTestStepResult;
+	
+}
+