// 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;
}