diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/testoutputstreamtruepause.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/testoutputstreamtruepause.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1883 @@ +// Copyright (c) 2008-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: +// Part of the TSI_MMFACLNT suite that tests CR1566 (TruePause) on AudioOutputStream +// +// + +/** + @file TestOutputStreamTruePause.cpp +*/ + +#include "testoutputstreamtruepause.h" + +/* + * + * RMdaOutputStreamTestBase - Test step constructor + * + */ +RMdaOutputStreamTestBase::RMdaOutputStreamTestBase(const TDesC& aTestName, const TDesC& aSectName) + : iAudioOutputStreamState(EStateAOSInitial), + iAudioOutputStream(NULL), + iTimer(NULL), + iWait(EFalse), + iConfig(EFalse), + iInvalidConfig(EFalse), + iGetBytes(EFalse), + iCount(0), + iVolume(0), + iBalance(0), + iDuration(0), + iPause(0), + iBytes(0), + iPosition(0), + iFilename(KNullDesC) + { + iTestStepName = aTestName; + iSectName = aSectName; + } + +/* + * + * ~RMdaOutputStreamTestBase - Test step destructor + * + */ +RMdaOutputStreamTestBase::~RMdaOutputStreamTestBase() + { + if (iAudioOutputStream) + { + delete iAudioOutputStream; + } + if(iTimer) + { + delete iTimer; + } + iFile.Close(); + iFs.Close(); + iBuffer.Close(); + } + +/* + * + * KickoffTestL - Starts the test + * + */ +void RMdaOutputStreamTestBase::KickoffTestL() + { + User::LeaveIfError(iFs.Connect()); + INFO_PRINTF1(_L("__________ Creating AudioOutputStream object ___________")); + + TRAPD(err, iAudioOutputStream = CMdaAudioOutputStream::NewL(*this)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Could not create Tone Utility object. Error = %d"), err); + StopTest(err); + return; + } + INFO_PRINTF1(_L("AudioOutputStream State: EStateCreated")); + iAudioOutputStreamState = EStateAOSCreated; + + DoKickoffTestL(); + + INFO_PRINTF1(_L("AudioOutputStream: EEventInitialize")); + Fsm(EEventAOSInitialize, KErrNone); + } + +/* + * + * CloseTest + * + */ +void RMdaOutputStreamTestBase::CloseTest() + { + INFO_PRINTF1(_L("Deleting AudioOutputStream object")); + delete iAudioOutputStream; + delete iTimer; + } + +/* + * + * StartTimer - Starts timer and timer callback + * + */ +void RMdaOutputStreamTestBase::StartTimer(TTimeIntervalMicroSeconds32 aWaitTime) + { + TTimeIntervalMicroSeconds32 timeInterval; + + if(aWaitTime <= TTimeIntervalMicroSeconds32(0)) + { + timeInterval = KOneSecond; + } + else + { + timeInterval = aWaitTime; + } + TCallBack callback (TimerCallback, this); + iTimer->Start(timeInterval, timeInterval, callback); + INFO_PRINTF1(_L("Timer has been started")); + } + +/* + * + * TimerCallback + * + */ +TInt RMdaOutputStreamTestBase::TimerCallback(TAny* aPtr) + { + static_cast(aPtr)->DoTimerCallback(); + return KErrNone; + } + +/* + * + * Fsm - Executes playing events of AudioToneUtility in sequence + * + */ +void RMdaOutputStreamTestBase::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError) + { + TInt error = 0; + TTimeIntervalMicroSeconds resumeposition; + switch (iAudioOutputStreamState) + { + case EStateAOSCreated: + { + if (aMdaAudioOutputStreamEvent == EEventAOSInitialize) + { + TMdaAudioDataSettings settings; + //Default settings + settings.Query(); + settings.iChannels = TMdaAudioDataSettings::EChannelsMono; + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open")); + iAudioOutputStream->Open(&settings); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing")); + iAudioOutputStreamState = EStateAOSInitializing; + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSInitializing: + { + if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone) + { + INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2")); + iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2); + INFO_PRINTF1(_L("Starting playback")); + iAudioOutputStream->WriteL(iBuffer); + iAudioOutputStreamState = EStateAOSPlaying; + StartTimer(iPause*KOneSecond); + } + else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone) + { + ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError); + StopTest(aError); + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSPlaying: + { + if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + if(!iGetBytes) + { + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause")); + error = iAudioOutputStream->Pause(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Pause returned with KErrNone as expected")); + } + else + { + ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + iPosition = iAudioOutputStream->Position(); + INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64()); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause")); + iAudioOutputStreamState = EStateAOSPause; + iWait = EFalse; + } + if(iGetBytes) + { + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause")); + error = iAudioOutputStream->Pause(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Pause returned with KErrNone as expected")); + } + else + { + ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause")); + iPosition = iAudioOutputStream->Position(); + INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64()); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause")); + iAudioOutputStreamState = EStateAOSPause; + iWait = EFalse; + INFO_PRINTF1(_L("Calling GetBytes")); + iBytes = iAudioOutputStream->GetBytes(); + } + } + else + { + ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSPause: + { + if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + if(!iWait && !iConfig && !iInvalidConfig && !iGetBytes) + { + if(iPosition == iAudioOutputStream->Position()) + { + INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64()); + StopTest(KErrGeneral); + } + INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume")); + error = iAudioOutputStream->Resume(); + resumeposition = iAudioOutputStream->Position(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Resume returned with KErrNone as expected")); + iAudioOutputStreamState = EStateAOSPlaying; + if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2) + { + INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64()); + StopTest(KErrGeneral); + } + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + } + else if(!iWait && iConfig) + { + if(iPosition == iAudioOutputStream->Position()) + { + INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64()); + StopTest(KErrGeneral); + } + INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause); + INFO_PRINTF3(_L("Changing Volume and Balance while paused to Volume = %d and Balance = %d"),iVolume,iBalance); + iAudioOutputStream->SetVolume(iVolume); + iAudioOutputStream->SetBalanceL(iBalance); + INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume")); + error = iAudioOutputStream->Resume(); + resumeposition = iAudioOutputStream->Position(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Resume returned with KErrNone as expected")); + iAudioOutputStreamState = EStateAOSPlaying; + if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2) + { + INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64()); + StopTest(KErrGeneral); + } + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + iConfig = EFalse; + } + else if(!iWait && iInvalidConfig) + { + if(iPosition == iAudioOutputStream->Position()) + { + INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64()); + StopTest(KErrGeneral); + } + INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause); + INFO_PRINTF1(_L("Changing AudioProperties while paused")); + TRAPD(err,iAudioOutputStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate48000Hz, TMdaAudioDataSettings::EChannelsStereo)); + if(err == KErrNotReady) + { + INFO_PRINTF1(_L("SetAudioPropertiesL returned with KErrNotReady as expected")); + INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume")); + error = iAudioOutputStream->Resume(); + resumeposition = iAudioOutputStream->Position(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Resume returned with KErrNone as expected")); + iAudioOutputStreamState = EStateAOSPlaying; + if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2) + { + INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64()); + StopTest(KErrGeneral); + } + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),err); + StopTest(err); + } + iInvalidConfig = EFalse; + } + else + { + ERR_PRINTF2(_L("SetAudioPropertiesL did not return with KErrNotSupported as expected, returned with %d instead"), err); + StopTest(KErrGeneral); + } + } + else if(!iWait && iGetBytes) + { + if(iPosition == iAudioOutputStream->Position()) + { + INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64()); + StopTest(KErrGeneral); + } + INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause); + INFO_PRINTF1(_L("Calling GetBytes to verify the value hasn't changed")); + TInt myBytes = iAudioOutputStream->GetBytes(); + if(myBytes == iBytes) + { + INFO_PRINTF1(_L("GetBytes value did not change while in pause, this is expected.")); + INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume")); + error = iAudioOutputStream->Resume(); + resumeposition = iAudioOutputStream->Position(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Resume returned with KErrNone as expected")); + iAudioOutputStreamState = EStateAOSPlaying; + if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2) + { + INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64()); + StopTest(KErrGeneral); + } + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + iGetBytes = EFalse; + } + else + { + ERR_PRINTF3(_L("GetBytes value changed while in pause, this is unexpected. Expected = %d Retrieved = %d"),iBytes,myBytes); + StopTest(KErrGeneral); + } + } + } + else + { + ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + default: + { + ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState); + StopTest(KErrGeneral); + } + } + } + +/* + * + * MaoscOpenComplete - From MMdaAudioOutputStreamObserver + * + */ +void RMdaOutputStreamTestBase::MaoscOpenComplete(TInt aError) + { + INFO_PRINTF1(_L("========== AudioOutputStream MaoscOpenComplete() callback ==========")); + if(iAudioOutputStreamState == EStateAOSInitializing) + { + INFO_PRINTF1(_L("AudioOutputStream MaoscOpenComplete")); + Fsm(EEventAOSOpenComplete, aError); + } + } + +/* + * + * MaoscBufferCopied - From MMdaAudioOutputStreamObserver + * + */ +void RMdaOutputStreamTestBase::MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + INFO_PRINTF1(_L("========== AudioOutputStream MaoscBufferCopied() callback ==========")); + INFO_PRINTF1(_L("Reading file")); + TInt err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + if (iBuffer != KNullDesC8 && iAudioOutputStreamState != EStateAOSStopped) + { + INFO_PRINTF1(_L("Writing to stream")); + iAudioOutputStream->WriteL(iBuffer); + } + if(iAudioOutputStreamState == EStateAOSPlaying) + { + INFO_PRINTF1(_L("AudioOutputStream MaoscBufferCopied")); + } + else if(iAudioOutputStreamState == EStateAOSPause) + { + ERR_PRINTF1(_L("AudioOutputStream MaoscBufferCopied in Paused. This is unexpected")); + StopTest(KErrGeneral); + } + } + +/* + * + * MaoscPlayComplete - From MMdaAudioOutputStreamObserver + * + */ +void RMdaOutputStreamTestBase::MaoscPlayComplete(TInt aError) + { + INFO_PRINTF1(_L("========== AudioOutputStream MaoscPlayComplete() callback ==========")); + if (aError == KErrUnderflow) + { + INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError); + StopTest(EPass); + } + else + { + ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError); + ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow); + StopTest(aError); + } + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0175-HP + *======================================================================================================== + */ +RMdaOutputStreamPauseResumeBeforeWriteTest::RMdaOutputStreamPauseResumeBeforeWriteTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamPauseResumeBeforeWriteTest* RMdaOutputStreamPauseResumeBeforeWriteTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamPauseResumeBeforeWriteTest * self = new(ELeave)RMdaOutputStreamPauseResumeBeforeWriteTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamPauseResumeBeforeWriteTest::DoKickoffTestL() + { + TPtrC filename; + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + iPause = KTimeout; //Set timeout to stop test if playback was paused + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * Fsm - Executes playing events of AudioToneUtility in sequence + * + */ +void RMdaOutputStreamPauseResumeBeforeWriteTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError) + { + TInt error = 0; + TTimeIntervalMicroSeconds resumeposition; + switch (iAudioOutputStreamState) + { + case EStateAOSCreated: + { + if (aMdaAudioOutputStreamEvent == EEventAOSInitialize) + { + TMdaAudioDataSettings settings; + //Default settings + settings.Query(); + settings.iChannels = TMdaAudioDataSettings::EChannelsMono; + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause before Open")); + error = iAudioOutputStream->Pause(); + if(error == KErrNotReady) + { + INFO_PRINTF1(_L("Pause before open returned with KErrNotReady as expected")); + } + else + { + ERR_PRINTF2(_L("Pause before open returned with %d instead of KErrNotReady as expected"),error); + StopTest(error); + } + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open")); + iAudioOutputStream->Open(&settings); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing")); + iAudioOutputStreamState = EStateAOSInitializing; + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSInitializing: + { + if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone) + { + INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2")); + iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2); + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause before first WriteL")); + error = iAudioOutputStream->Pause(); + if(error == KErrNotReady) + { + INFO_PRINTF1(_L("Pause before first WriteL returned with KErrNotReady as expected")); + } + else + { + ERR_PRINTF2(_L("Pause before first WriteL returned with %d instead of KErrNotReady as expected"),error); + StopTest(error); + } + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume before first WriteL")); + error = iAudioOutputStream->Resume(); + if(error == KErrNotReady) + { + INFO_PRINTF1(_L("Resume before first WriteL returned with KErrNotReady as expected")); + } + else + { + ERR_PRINTF2(_L("Resume before first WriteL returned with %d instead of KErrNotReady as expected"),error); + StopTest(error); + } + INFO_PRINTF1(_L("Starting playback")); + iAudioOutputStream->WriteL(iBuffer); + iAudioOutputStreamState = EStateAOSPlaying; + StartTimer(iPause*KOneSecond); + } + else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone) + { + ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError); + StopTest(aError); + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + default: + { + ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState); + StopTest(KErrGeneral); + } + } + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamPauseResumeBeforeWriteTest::DoTimerCallback() + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + ERR_PRINTF1(_L("Playback was paused when it shouldn't")); + StopTest(KErrGeneral); + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0176-HP + *======================================================================================================== + */ +RMdaOutputStreamResumeTest::RMdaOutputStreamResumeTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamResumeTest* RMdaOutputStreamResumeTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamResumeTest * self = new(ELeave)RMdaOutputStreamResumeTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamResumeTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamResumeTest::DoTimerCallback() + { + if(!iWait) + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + } + else + { + INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete")); + } + Fsm (EEventAOSTimerComplete, KErrNone); + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0177-HP + *======================================================================================================== + */ +RMdaOutputStreamResumeThriceTest::RMdaOutputStreamResumeThriceTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamResumeThriceTest* RMdaOutputStreamResumeThriceTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamResumeThriceTest * self = new(ELeave)RMdaOutputStreamResumeThriceTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamResumeThriceTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamResumeThriceTest::DoTimerCallback() + { + iCount++; + if(!iWait && iCount == 2*KRepeatThrice) //Repeating Pause-Resume cycle three times. Timer should be called 6 times + { + iTimer->Cancel(); + Fsm (EEventAOSTimerComplete, KErrNone); + } + else + { + INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete")); + Fsm (EEventAOSTimerComplete, KErrNone); + } + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0178-HP + *======================================================================================================== + */ +RMdaOutputStreamConfigInPauseTest::RMdaOutputStreamConfigInPauseTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamConfigInPauseTest* RMdaOutputStreamConfigInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamConfigInPauseTest * self = new(ELeave)RMdaOutputStreamConfigInPauseTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamConfigInPauseTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the volume + if (!GetIntFromConfig(iSectName, KVolume, iVolume)) + { + ERR_PRINTF1(_L("Volume could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the balance + if (!GetIntFromConfig(iSectName, KBalance, iBalance)) + { + ERR_PRINTF1(_L("Balance could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + iConfig = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamConfigInPauseTest::DoTimerCallback() + { + if(!iWait && !iConfig) + { + iTimer->Cancel(); + INFO_PRINTF1(_L("Comparing Volume and Balance with values set")); + if (iVolume == iAudioOutputStream->Volume() && Abs(iBalance - iAudioOutputStream->GetBalanceL())Volume(),iAudioOutputStream->GetBalanceL(),iVolume,iBalance); + StopTest(KErrGeneral); + } + } + else + { + INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete")); + Fsm (EEventAOSTimerComplete, KErrNone); + } + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0179-HP + *======================================================================================================== + */ +RMdaOutputStreamInvalidConfigInPauseTest::RMdaOutputStreamInvalidConfigInPauseTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamInvalidConfigInPauseTest* RMdaOutputStreamInvalidConfigInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamInvalidConfigInPauseTest * self = new(ELeave)RMdaOutputStreamInvalidConfigInPauseTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamInvalidConfigInPauseTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + iInvalidConfig = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamInvalidConfigInPauseTest::DoTimerCallback() + { + if(!iWait) + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + } + else + { + INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete")); + } + Fsm (EEventAOSTimerComplete, KErrNone); + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0180-HP + *======================================================================================================== + */ +RMdaOutputStreamGetBytesInPauseTest::RMdaOutputStreamGetBytesInPauseTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamGetBytesInPauseTest* RMdaOutputStreamGetBytesInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamGetBytesInPauseTest * self = new(ELeave)RMdaOutputStreamGetBytesInPauseTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamGetBytesInPauseTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + iGetBytes = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamGetBytesInPauseTest::DoTimerCallback() + { + if(!iWait) + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + } + else + { + INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete")); + } + Fsm (EEventAOSTimerComplete, KErrNone); + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0181-HP + *======================================================================================================== + */ +RMdaOutputStreamPlayPauseStopPlayTest::RMdaOutputStreamPlayPauseStopPlayTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamPlayPauseStopPlayTest* RMdaOutputStreamPlayPauseStopPlayTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamPlayPauseStopPlayTest * self = new(ELeave)RMdaOutputStreamPlayPauseStopPlayTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamPlayPauseStopPlayTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + iStop = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamPlayPauseStopPlayTest::DoTimerCallback() + { + if(!iWait && iStop) + { + iAudioOutputStreamState = EStateAOSStopped; + iStop = EFalse; + iWait = ETrue; + INFO_PRINTF1(_L("MAudioOutputStream Event: EEventTimerComplete")); + Fsm (EEventAOSTimerComplete, KErrNone); + } + else if(!iWait && !iStop) + { + iTimer->Cancel(); + Fsm (EEventAOSTimerComplete, KErrNone); + } + else + { + INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete")); + Fsm (EEventAOSTimerComplete, KErrNone); + } + } + +/* + * + * Fsm - Executes playing events of AudioToneUtility in sequence + * + */ +void RMdaOutputStreamPlayPauseStopPlayTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError) + { + TInt error = 0; + TTimeIntervalMicroSeconds resumeposition; + switch (iAudioOutputStreamState) + { + case EStateAOSCreated: + { + if (aMdaAudioOutputStreamEvent == EEventAOSInitialize) + { + TMdaAudioDataSettings settings; + //Default settings + settings.Query(); + settings.iChannels = TMdaAudioDataSettings::EChannelsMono; + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open")); + iAudioOutputStream->Open(&settings); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing")); + iAudioOutputStreamState = EStateAOSInitializing; + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSInitializing: + { + if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone) + { + INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2")); + iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2); + INFO_PRINTF1(_L("Starting playback")); + iAudioOutputStream->WriteL(iBuffer); + iAudioOutputStreamState = EStateAOSPlaying; + StartTimer(iPause*KOneSecond); + } + else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone) + { + ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError); + StopTest(aError); + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSPlaying: + { + if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause")); + error = iAudioOutputStream->Pause(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Pause returned with KErrNone as expected")); + } + else + { + ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + iPosition = iAudioOutputStream->Position(); + INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64()); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause")); + iAudioOutputStreamState = EStateAOSPause; + iWait = EFalse; + } + else + { + ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSPause: + { + if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + if(iPosition == iAudioOutputStream->Position()) + { + INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64()); + StopTest(KErrGeneral); + } + INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume")); + error = iAudioOutputStream->Resume(); + resumeposition = iAudioOutputStream->Position(); + if(error == KErrNone) + { + INFO_PRINTF1(_L("Resume returned with KErrNone as expected")); + iAudioOutputStreamState = EStateAOSPlaying; + if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2) + { + INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64()); + } + else + { + ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64()); + StopTest(KErrGeneral); + } + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error); + StopTest(error); + } + } + else + { + ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSStopped: + { + if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + if(iWait) + { + INFO_PRINTF1(_L("Stopping playback for 2 seconds")); + iAudioOutputStream->Stop(); + iWait = EFalse; + } + else + { + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume while in Stop")); + error = iAudioOutputStream->Resume(); + if(error == KErrNotReady) + { + INFO_PRINTF1(_L("Resume returned with KErrNotReady as expected")); + } + else + { + ERR_PRINTF2(_L("Resume returned with %d instead of KErrNotReady as expected"),error); + StopTest(error); + } + TInt filepos = 0; + INFO_PRINTF1(_L("Restarting file to start position")); + error = iFile.Seek(ESeekStart, filepos); + if (error != KErrNone) + { + INFO_PRINTF2(_L("Error restarting iFile %d"), error); + StopTest(error); + } + error = iFile.Read(iBuffer); + if (error != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), error); + StopTest(error); + } + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::WriteL while in Stop to restart playback")); + iAudioOutputStream->WriteL(iBuffer); + iAudioOutputStreamState = EStateAOSPlaying; + } + } + else + { + ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + default: + { + ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState); + StopTest(KErrGeneral); + } + } + } + +/* + * + * MaoscPlayComplete - From MMdaAudioOutputStreamObserver + * + */ +void RMdaOutputStreamPlayPauseStopPlayTest::MaoscPlayComplete(TInt aError) + { + INFO_PRINTF1(_L("========== AudioOutputStream MaoscPlayComplete() callback ==========")); + if(iAudioOutputStreamState == EStateAOSStopped) + { + if (aError == KErrCancel) + { + INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError); + } + else + { + ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError); + ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow); + StopTest(aError); + } + } + else if(iAudioOutputStreamState == EStateAOSPlaying) + { + if(aError == KErrUnderflow) + { + INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError); + StopTest(EPass); + } + else + { + ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError); + ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow); + StopTest(aError); + } + } + else + { + ERR_PRINTF1(_L("AudioOutputStream called MaoscPlayComplete at invalid state")); + StopTest(KErrGeneral); + } + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0182-HP + *======================================================================================================== + */ +RMdaOutputStreamInvalidFormatsTest::RMdaOutputStreamInvalidFormatsTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamInvalidFormatsTest* RMdaOutputStreamInvalidFormatsTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamInvalidFormatsTest * self = new(ELeave)RMdaOutputStreamInvalidFormatsTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamInvalidFormatsTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KOggFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iWait = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamInvalidFormatsTest::DoTimerCallback() + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + Fsm (EEventAOSTimerComplete, KErrNone); + } + +/* + * + * Fsm - Executes playing events of AudioToneUtility in sequence + * + */ +void RMdaOutputStreamInvalidFormatsTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError) + { + TInt error = 0; + TTimeIntervalMicroSeconds resumeposition; + switch (iAudioOutputStreamState) + { + case EStateAOSCreated: + { + if (aMdaAudioOutputStreamEvent == EEventAOSInitialize) + { + TMdaAudioDataSettings settings; + //setting for OGG file + settings.Query(); + settings.iChannels = TMdaAudioDataSettings::EChannelsStereo; + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate44100Hz; + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open")); + iAudioOutputStream->Open(&settings); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing")); + iAudioOutputStreamState = EStateAOSInitializing; + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSInitializing: + { + if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone) + { + TFourCC KVORBDataType('V', 'O', 'R', 'B'); + TRAPD(err,iAudioOutputStream->SetDataTypeL(KVORBDataType)); + if(err != KErrNone) + { + INFO_PRINTF1(_L("Failed to set non-PCM Format")); + StopTest(err); + } + INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2")); + iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2); + INFO_PRINTF1(_L("Starting playback")); + iAudioOutputStream->WriteL(iBuffer); + iAudioOutputStreamState = EStateAOSPlaying; + StartTimer(iPause*KOneSecond); + } + else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone) + { + ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError); + StopTest(aError); + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSPlaying: + { + if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete) + { + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause while playing non-PCM format")); + error = iAudioOutputStream->Pause(); + if(error == KErrNotSupported) + { + INFO_PRINTF1(_L("Pause while playing non-PCM format returned with KErrNotSupported as expected")); + } + else + { + ERR_PRINTF2(_L("Pause while playing non-PCM format returned with %d instead of KErrNotReady as expected"),error); + StopTest(error); + } + } + else + { + ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + default: + { + ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState); + StopTest(KErrGeneral); + } + } + } + +/* + *======================================================================================================== + * MM-MMF-ACLNT-I-0184-HP + *======================================================================================================== + */ +RMdaOutputStreamPauseNonA3FTest::RMdaOutputStreamPauseNonA3FTest(const TDesC& aTestName, const TDesC& aSectName) + : RMdaOutputStreamTestBase(aTestName,aSectName) + { + } + +/* + * + * NewL + * + */ +RMdaOutputStreamPauseNonA3FTest* RMdaOutputStreamPauseNonA3FTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + RMdaOutputStreamPauseNonA3FTest * self = new(ELeave)RMdaOutputStreamPauseNonA3FTest(aTestName,aSectName); + return self; + } + +/* + * + * DoKickoffTestL + * + */ +void RMdaOutputStreamPauseNonA3FTest::DoKickoffTestL() + { + TPtrC filename; + // Get the pause time + if (!GetIntFromConfig(iSectName, KPause, iPause)) + { + ERR_PRINTF1(_L("Pause time could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // Get the filename of the audio file to play + if (!GetStringFromConfig(iSectName, KRawFile, filename)) + { + ERR_PRINTF1(_L("Filename could not be retrieved from ini file")); + StopTest(KErrNotFound); + return; + } + // open using RFile for playback + iFilename.Copy(filename); + TInt err = iFile.Open(iFs, iFilename, EFileRead); + if (err != KErrNone) + { + ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err); + iFs.Close(); + StopTest(err); + return; + } + // Get size of iFile + TInt filesize = 0; + err = iFile.Size(filesize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of iFile = %d"), err); + StopTest(err); + return; + } + // Initialise iBuf + iBuffer.CreateMaxL(filesize/KFileDivision); + + //Read first half of the file + err = iFile.Read(iBuffer); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading iFile %d"), err); + StopTest(err); + } + + iPause = KTimeout; //Set timeout to stop test if playback was paused + iWait = ETrue; + INFO_PRINTF2(_L("File under test -> %S"), &iFilename); + iTimer = CPeriodic::NewL(CActive::EPriorityHigh); + } + +/* + * + * DoTimerCallback + * + */ +void RMdaOutputStreamPauseNonA3FTest::DoTimerCallback() + { + INFO_PRINTF1(_L("Cancelling timer")); + iTimer->Cancel(); + ERR_PRINTF1(_L("Playback was paused when it shouldn't")); + StopTest(KErrGeneral); + } + +/* + * + * Fsm - Executes playing events of AudioToneUtility in sequence + * + */ +void RMdaOutputStreamPauseNonA3FTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError) + { + switch (iAudioOutputStreamState) + { + case EStateAOSCreated: + { + if (aMdaAudioOutputStreamEvent == EEventAOSInitialize) + { + TMdaAudioDataSettings settings; + //Default settings + settings.Query(); + settings.iChannels = TMdaAudioDataSettings::EChannelsMono; + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open")); + iAudioOutputStream->Open(&settings); + INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing")); + iAudioOutputStreamState = EStateAOSInitializing; + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + case EStateAOSInitializing: + { + if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone) + { + INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2")); + iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2); + INFO_PRINTF1(_L("Starting playback")); + iAudioOutputStream->WriteL(iBuffer); + StartTimer(iPause*KOneSecond); + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause in non-a3f configuration")); + TInt err = iAudioOutputStream->Pause(); + if(err == KErrNotSupported) + { + INFO_PRINTF1(_L("Pause in CMdaAudioOutputStream returned with KErrNotSupported as expected")); + } + else + { + ERR_PRINTF2(_L("Pause in CMdaAudioOutputStream returned with %d instead of KErrNotSupported as expected"),err); + StopTest(err); + } + INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume in non-a3f configuration")); + err = iAudioOutputStream->Resume(); + if(err == KErrNotReady) + { + INFO_PRINTF1(_L("Resume in CMdaAudioOutputStream returned with KErrNotReady as expected")); + } + else + { + ERR_PRINTF2(_L("Resume in CMdaAudioOutputStream returned with %d instead of KErrNotReady as expected"),err); + StopTest(err); + } + } + else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone) + { + ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError); + StopTest(aError); + } + else + { + ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent); + StopTest(aError, EFail); + } + break; + } + default: + { + ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState); + StopTest(KErrGeneral); + } + } + }