diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestPlayerUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestPlayerUtils.cpp Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,4466 @@ +// 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 program is designed the test of the MMF_ACLNT. +// +// + +/** + @file TestPlayerUtils.cpp +*/ + + +#include "TestPlayerUtils.h" +#include + +// constant table of parameters for tests +const TRepeatParameters KTestParameters[] = +{ + { _S("playerAudioFile"), 1, 1}, + { _S("Pcm16Mono12khz"), 3, 3}, + { _S("PCM8"), 3, 3}, + { _S("PCM8-6144bytes"), 1, 1}, + { _S("ALAW"), 3, 3}, + { _S("PCM16"), 1, 1}, + { _S("PCMU8"), 2, 2}, + { _S("PCMU16BE"), 3, 3}, + { _S("PCMU16"), 1, 1}, + { _S("MULAW"), 2, 2}, + { _S("Sequence1"), 2, 2}, + { _S("Sequence2"), 3, 3}, + { _S("IMAD"), 3, 3}, + { _S("GSM610"), 1, 1}, + { _S("Pcm8Mono44khz"), 2, 2}, + { _S("Pcm16Mono44khz"), 3, 3}, + { _S("Pcm16Mono48khz"), 1, 1}, + { _S("100khzSRate1KhzTone"), 2, 2}, + { _S("Pcm16Mono24khz"), 3, 3}, + { _S("playerAudioFile2"), 2, 2} +}; + +const TInt KNoOfTestFiles = 20; +TAny GetDriveName(TDes& aFileName) +{ +#ifdef __WINS__ + aFileName = _L("c:"); +#elif defined(__MARM__) || defined(__X86GCC__) + #ifdef __TEST_FILES_ON_C_DRIVE__ + aFileName = _L("c:"); + #else + aFileName = _L("z:"); + #endif // __TEST_FILES_ON_C_DRIVE__ +#endif +} + + +#define STOP_TEST_GEN_ERROR ERR_PRINTF1(_L("State machine error")), StopTest(KErrGeneral, EFail) +/** + * Constructor + */ +CTestMmfAclntFile::CTestMmfAclntFile(const TDesC& aTestName,const TDesC& aSectName, + const TDesC& aKeyName,const TBool aPlay, + const TInt aExpectedError) + :iPlay (aPlay) + ,iExpectedError (aExpectedError) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMmfAclntFile* CTestMmfAclntFile::NewL(const TDesC& aTestName, const TDesC& aSectName, + const TDesC& aKeyName,const TBool aPlay, + const TInt aExpectedError = KErrNone) + { + CTestMmfAclntFile* self = new (ELeave) CTestMmfAclntFile(aTestName,aSectName,aKeyName,aPlay,aExpectedError); + return self; + } + +CTestMmfAclntFile* CTestMmfAclntFile::NewLC(const TDesC& aTestName, const TDesC& aSectName, + const TDesC& aKeyName, + const TBool aPlay, + const TInt aExpectedError) + { + CTestMmfAclntFile* self = CTestMmfAclntFile::NewL(aTestName,aSectName,aKeyName,aPlay,aExpectedError); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iDuration = aDuration; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntFile::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1(_L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + + + +/** Load and initialise an audio file. + */ +TVerdict CTestMmfAclntFile::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : File")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName,iKeyName,filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + CMdaAudioPlayerUtility* player = NULL; + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &filename); + player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this); + + if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2001-HP"))==0) + { + // Check file size is more than 0 + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error connecting to file session (%d)"), err); + return EInconclusive; + } + CleanupClosePushL(fs); + TEntry fileEntry; + err = fs.Entry(filename, fileEntry); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting file entry (%d)"), err); + fs.Close(); + return EInconclusive; + } + if (fileEntry.iSize <= 0) + { + INFO_PRINTF2(_L("Test file '%S' has size %d"), fileEntry.iSize); + fs.Close(); + return EInconclusive; + + } + CleanupStack::PopAndDestroy(); // fs + } + +#ifndef __WINS__ + if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2014-LP")) == 0) + { + // this test should not be run on Lubbock + INFO_PRINTF1(_L("Lubbock hardware is not fast enough to convert 100KHz audio.")); + INFO_PRINTF1(_L("This test has been skipped for this reason...")); + + delete player; + User::After(KOneSecond); // wait for deletion to shut down devsound + + return EPass; + } +#endif + + // Wait for initialisation callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone && (iExpectedError == iError)) + { + if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-1008-HP")) == 0) + { + // Test is for non-existent file - check that the file has not been created + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + ret = EInconclusive; + } + else + { + TEntry entry; + if (fs.Entry(filename, entry) == KErrNone) + { + ret = EFail; // file exists - test fails + } + + else + ret = EPass; + fs.Close(); + } + } + else + { + ret = EPass; // all other tests pass + } + delete player; + User::After(KOneSecond); // wait for deletion to shut down devsound + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expectable error %d"),iError ); + return ret; + } + // Check for errors. + if (iError == KErrNone && player != NULL) + { + if(iPlay) + { + iError = KErrTimedOut; + player->Play(); + + // Wait for init callback + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + //can't use iExpected Error as is doesn't distinguish between + //error from NewFilePlayerL or PlayL. + if ((iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2015-LP")) == 0)) + { + if(iError == KErrNotSupported) + { + ret = EPass; + } + } + else if(iError == KErrNone) + ret = EPass; + } + else + ret = EPass; + } + + delete player; + User::After(KOneSecond); // wait for deletion to shut down devsound + if(iError != KErrNone) + { + if ((iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2014-LP")) == 0) && iError==KErrNotSupported) + { + //Sampling Rate greater than 96000 Hz is not expected in data , and we dont support this. + //This test has been changed to expect KErrNotSupported due to fix in PDEF131534 + INFO_PRINTF1( _L("CMdaAudiPlayerUtility returned KErrNotSupported as expected")); + ret= EPass; + } + else + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + } + + return ret; + } + + + + + + + +/** + * Constructor + */ +CTestMmfAclntSEQNFile::CTestMmfAclntSEQNFile(const TDesC& aTestName,const TDesC& aSectName, + const TDesC& aKeyName, + const TBool aPlay, + const TBool aIsFile) + :iPlay (aPlay) + ,iIsFile (aIsFile) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMmfAclntSEQNFile* CTestMmfAclntSEQNFile::NewL(const TDesC& aTestName, const TDesC& aSectName, + const TDesC& aKeyName, + const TBool aPlay, + const TBool aIsFile) + { + CTestMmfAclntSEQNFile* self = new (ELeave) CTestMmfAclntSEQNFile(aTestName,aSectName,aKeyName,aPlay,aIsFile); + return self; + } + +CTestMmfAclntSEQNFile* CTestMmfAclntSEQNFile::NewLC(const TDesC& aTestName, const TDesC& aSectName, + const TDesC& aKeyName, + const TBool aPlay, + const TBool aIsFile) + { + CTestMmfAclntSEQNFile* self = CTestMmfAclntSEQNFile::NewL(aTestName,aSectName,aKeyName,aPlay,aIsFile); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntSEQNFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iDuration = aDuration; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntSEQNFile::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + + +//This method is used to stop playing the file 1 second after we started +void CTestMmfAclntSEQNFile::DelayedMethodCallL() +{ +CActiveScheduler::Stop(); +} + + + +/** Load and play an audio sequence file. + */ +TVerdict CTestMmfAclntSEQNFile::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : File")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName,iKeyName,filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + + CMdaAudioPlayerUtility* player = NULL; + HBufC8* seqnDesc = NULL; + RFile file; + RFs fs; + + if(iIsFile) + { + player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this); + } + else + { + + User::LeaveIfError(fs.Connect()); +//TIMB + User::LeaveIfError(file.Open(fs, filename, EFileShareReadersOnly | EFileStream)); + CleanupClosePushL(file); + + TInt size; + User::LeaveIfError(file.Size(size)); + + seqnDesc = HBufC8::NewMaxLC(size); + + TPtr8 bufferDes(seqnDesc->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + player = CMdaAudioPlayerUtility::NewDesPlayerL(bufferDes, *this); + } + + CleanupStack::PushL(player); + + // Wait for initialisation callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + + if(iError == KErrNone) + { + TInt maxVol = player->MaxVolume(); + player->SetVolume(maxVol/2); + TInt gotVol; + iError = player->GetVolume(gotVol); + + if((iError != KErrNone) || (maxVol/2 != gotVol)) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests")); + if(iError == KErrNone) + iError = KErrGeneral; + } + } + + + if(iError == KErrNone) + { + TTimeIntervalMicroSeconds t(0); + TTimeIntervalMicroSeconds zeroUs(0); + + t = player->Duration(); + + if(t != zeroUs) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed duration test")); + iError = KErrGeneral; + } + + player->SetPosition(zeroUs); + iError = player->GetPosition(t); + + if((t != zeroUs) || (iError != KErrNone)) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed duration test")); + if(iError == KErrNone) + iError = KErrGeneral; + } + } + + if(iError == KErrNone) + { + TInt entries; + TInt metaErr = KErrNone; + + metaErr = player->GetNumberOfMetaDataEntries(entries); + + if(metaErr != KErrNotSupported) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests")); + iError = metaErr; + } + else + { + CMMFMetaDataEntry* metaEntry = NULL; // EABI warning removal - "metaEntry was set but never used" + + TRAP(metaErr, metaEntry = player->GetMetaDataEntryL(0)); // EABI warning removal - "metaEntry was set but never used" + + + if(metaErr != KErrNotSupported) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests")); + iError = metaErr; + if (metaErr==KErrNone) + { + delete metaEntry; + } + } + } + } + + + + if(iError == KErrNone) + { + player->SetBalance(KMMFBalanceMaxLeft); + TInt bal = KMMFBalanceCenter; + + iError = player->GetBalance(bal); + + if(bal != KMMFBalanceMaxLeft) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed balance tests")); + if(iError == KErrNone) + iError = KErrGeneral; + } + else + player->SetBalance(KMMFBalanceCenter); + } + + + if(iError == KErrNone) + { + TInt priErr = player->SetPriority(EMdaPriorityMin, EMdaPriorityPreferenceNone); + + if(priErr != KErrNone) + { + ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed priority tests")); + iError = KErrGeneral; + } + else + player->SetPriority(EMdaPriorityNormal, EMdaPriorityPreferenceNone); + } + + + + + if(iError == KErrNone) + { + iError = KErrTimedOut; + player->Play(); + + //Stop the player after one second and restart + CDelayedMethodCall* delayedMethodCall = CDelayedMethodCall::NewL(this); + CleanupStack::PushL(delayedMethodCall); + delayedMethodCall->After(KOneSecond); + + CActiveScheduler::Start(); + + CleanupStack::PopAndDestroy(delayedMethodCall); + + player->Stop(); + + player->Play(); + CActiveScheduler::Start(); + } + + + + CleanupStack::PopAndDestroy(player); + if(iIsFile == EFalse) + { + CleanupStack::PopAndDestroy(seqnDesc); + CleanupStack::PopAndDestroy(&file); + } + + User::After(KOneSecond); // wait for deletion to shut down devsound + if(iError == KErrNone) + { + ret = EPass; + } + + else + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + + return ret; + } + + + + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntDesc::CTestMmfAclntDesc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TBool aPlay, const TInt aExpectedError) + :iPlay (aPlay), + iExpectedError(aExpectedError) + + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMmfAclntDesc* CTestMmfAclntDesc::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError) + { + CTestMmfAclntDesc* self = new (ELeave) CTestMmfAclntDesc(aTestName,aSectName,aKeyName,aPlay,aExpectedError); + return self; + } + +CTestMmfAclntDesc* CTestMmfAclntDesc::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError = KErrNone) + { + CTestMmfAclntDesc* self = CTestMmfAclntDesc::NewLC(aTestName,aSectName,aKeyName,aPlay, aExpectedError); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntDesc::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iDuration = aDuration; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntDesc::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntDesc::DoTestStepPreambleL() + { + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + RFs fs; + RFile file; + TInt size = 0; + TInt returnCode = 0; + // connect to file system and open file + + CleanupClosePushL(file); + + returnCode = fs.Connect(); + if (returnCode != KErrNone) + { + ERR_PRINTF2(_L("Failed to connect to file server, error %d"), returnCode); + fs.Close(); + return EFail; + } + + returnCode = file.Open(fs,filename,EFileRead); + if (returnCode != KErrNone) + { + ERR_PRINTF2(_L("Failed to Open the file, error %d"), returnCode); + file.Close(); + return EFail; + } + + INFO_PRINTF2( _L("File opened successfully %S"), &filename); + + // Set HBuf size + User::LeaveIfError(file.Size(size)); + INFO_PRINTF2(_L("size of file = %d\n"),size); //Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(size); + // read data into Hbuf + TPtr8 bufferDes(iAudio->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + CleanupStack::PopAndDestroy(); //file + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntDesc::DoTestStepPostambleL() + { + delete iAudio; + delete iPlayer; + iPlayer = NULL; + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * Load and initialise an audio descriptor. + */ +TVerdict CTestMmfAclntDesc::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Desc")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TPtr8 bufferDes(iAudio->Des()); + iPlayer = CMdaAudioPlayerUtility::NewDesPlayerL(bufferDes, *this); + // Wait for init callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone && iError == iExpectedError) + { + delete iPlayer; + iPlayer = NULL; + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expected error %d"),iError ); + return EPass; + } + + if (iError == KErrNone && iPlayer != NULL) + { + if(iPlay) + { + iError = KErrTimedOut; + iPlayer->Play(); + // Wait for init callback + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + if(iError == KErrNone) + { + ret = EPass; + } + + } + else + ret = EPass; + } + + if(iError != KErrNone) + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + return ret; + } + +//------------------------------------------------------------------ + +/** + * Load and initialise an audio descriptor - read-only + */ + +CTestMmfAclntDescReadOnly::CTestMmfAclntDescReadOnly(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TBool aPlay, const TInt aExpectedError) + :CTestMmfAclntDesc(aTestName, aSectName, aKeyName, aPlay, aExpectedError) + { + } + +CTestMmfAclntDescReadOnly* CTestMmfAclntDescReadOnly::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError) + { + CTestMmfAclntDescReadOnly* self = new (ELeave) CTestMmfAclntDescReadOnly(aTestName,aSectName,aKeyName,aPlay,aExpectedError); + return self; + } + +CTestMmfAclntDescReadOnly* CTestMmfAclntDescReadOnly::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError = KErrNone) + { + CTestMmfAclntDescReadOnly* self = CTestMmfAclntDescReadOnly::NewLC(aTestName,aSectName,aKeyName,aPlay, aExpectedError); + CleanupStack::PushL(self); + return self; + } + +TVerdict CTestMmfAclntDescReadOnly::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Desc (Read-Only)")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TPtr8 bufferDes(iAudio->Des()); + iPlayer = CMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(bufferDes, *this); + // Wait for init callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone && iError == iExpectedError) + { + delete iPlayer; + iPlayer = NULL; + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expected error %d"),iError ); + return EPass; + } + + if (iError == KErrNone && iPlayer != NULL) + { + if(iPlay) + { + iError = KErrTimedOut; + iPlayer->Play(); + // Wait for init callback + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + if(iError == KErrNone) + { + ret = EPass; + } + } + else + ret = EPass; + } + + delete iPlayer; + iPlayer = NULL; + if(iError != KErrNone) + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + + return ret; + } + +//------------------------------------------------------------------ + +/** + * Load and initialise an audio descriptor, using Open only + */ + +CTestMmfAclntDescOpen::CTestMmfAclntDescOpen(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TBool aPlay, const TInt aExpectedError) + :CTestMmfAclntDesc(aTestName, aSectName, aKeyName, aPlay, aExpectedError) + { + } + +CTestMmfAclntDescOpen* CTestMmfAclntDescOpen::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError) + { + CTestMmfAclntDescOpen* self = new (ELeave) CTestMmfAclntDescOpen(aTestName,aSectName,aKeyName,aPlay,aExpectedError); + return self; + } + +CTestMmfAclntDescOpen* CTestMmfAclntDescOpen::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError = KErrNone) + { + CTestMmfAclntDescOpen* self = CTestMmfAclntDescOpen::NewLC(aTestName,aSectName,aKeyName,aPlay, aExpectedError); + CleanupStack::PushL(self); + return self; + } + +TVerdict CTestMmfAclntDescOpen::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Desc (Open)")); + TVerdict ret = EFail; + + TPtr8 bufferDes(iAudio->Des()); + TRAPD(err, iPlayer = CMdaAudioPlayerUtility::NewL(*this)); + if(err != KErrNone) + { + delete iPlayer; + iPlayer = NULL; + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expected error %d"),iError ); + return EFail; + } + + if (err == KErrNone && iPlayer != NULL) + { + iError = KErrTimedOut; + TRAP_IGNORE(iPlayer->OpenDesL(bufferDes)); + // Wait for init callback + INFO_PRINTF1( _L("OpenDesL CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + if(iError == KErrNone) + { + ret = EPass; + } + } + + delete iPlayer; + iPlayer = NULL; + if(iError != KErrNone) + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + + return ret; + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntUrl::CTestMmfAclntUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + :iPlay (aPlay) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMmfAclntUrl* CTestMmfAclntUrl::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMmfAclntUrl* self = new (ELeave) CTestMmfAclntUrl(aTestName,aSectName,aKeyName,aPlay); + return self; + } + +CTestMmfAclntUrl* CTestMmfAclntUrl::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMmfAclntUrl* self = CTestMmfAclntUrl::NewLC(aTestName,aSectName,aKeyName,aPlay); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntUrl::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iDuration = aDuration; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntUrl::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + +/** + * Open audio from a URL and play. + */ +TVerdict CTestMmfAclntUrl::DoTestStepL() + { + INFO_PRINTF1( _L("TestPlayerUtils : URL")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TPtrC urlname; + if(!GetStringFromConfig(iSectName,iKeyName,urlname)) + { + return EInconclusive; + } + + + CMdaAudioPlayerUtility* player = CMdaAudioPlayerUtility::NewL(*this); + CleanupStack::PushL(player); + + TRAPD(err, player->OpenUrlL(urlname)); + if(err) + { + if(err != KErrNotSupported) + { + ERR_PRINTF2( _L("OpenUrlL left with error %d"), err); + CleanupStack::PopAndDestroy(player); + return EFail; + } + else + { + INFO_PRINTF2( _L("OpenUrlL left with expected error %d"), err); + CleanupStack::PopAndDestroy(player); + return EPass; + } + } + + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + if (iError == KErrNotSupported) + { + ret = EPass; + } + + + CleanupStack::PopAndDestroy(player); + if(iError != KErrNone) + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + + return ret; + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntAudioPlayerUtil::CTestMmfAclntAudioPlayerUtil(const TDesC& aTestName, const TDesC& aSectName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName=aTestName; + iStop = ETrue; + iSectName = aSectName; + } + + +void CTestMmfAclntAudioPlayerUtil::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iDuration = aDuration; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + + } + +void CTestMmfAclntAudioPlayerUtil::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + if(iStop) + { + CActiveScheduler::Stop(); + } + } + + + +/** + * Pause play and continue play. + */ +TVerdict CTestMmfAclntAudioPlayerUtil::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Player Util")); + + TVerdict ret = EFail; + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &filename); + CMdaAudioPlayerUtility* player = CMdaAudioPlayerUtility::NewFilePlayerL(filename,*this); + CleanupStack::PushL(player); + // wait for initilisation callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + // Attempt to wait out the in use error message!!! + // It may just be that we have the file locked. + if(iError == KErrInUse) + { + if(!GetStringFromConfig(iSectName, _L("playerAudioFile2"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + User::After(KTwoSeconds); + CleanupStack::PopAndDestroy(player); + User::After(KTwoSeconds); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &filename); + player = CMdaAudioPlayerUtility::NewFilePlayerL(filename,*this); + CleanupStack::PushL(player); + // wait for initilisation callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + } + + if (iError == KErrNone) + { + // no errors so far, Do Test! + ret = DoTestL(player); + } + + CleanupStack::PopAndDestroy(player); + User::After(KOneSecond); + if (iError != KErrNone) + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + + return ret; + } +//======================================================================================= +/** + * Constructor + */ +CAsyncTestMmfAclntAudioPlayerUtil::CAsyncTestMmfAclntAudioPlayerUtil ( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName=aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + + +void CAsyncTestMmfAclntAudioPlayerUtil::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iClipDuration = aDuration; + if (aError != KErrNone) + { + ERR_PRINTF2(_L("*MapcInitComplete* Error: %d."), aError); + StopTest(aError, EFail); + } + else + { + INFO_PRINTF2(_L("*MapcInitComplete* Error: %d."), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateOpened; + iPlayerState = EOpened; + } + } + +void CAsyncTestMmfAclntAudioPlayerUtil::MapcPlayComplete(TInt aError) + { + if(aError == KErrNone) + { + INFO_PRINTF2(_L("*MapcPlayComplete* Error: %d."), iError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateStopTest; + } + else + { + ERR_PRINTF2(_L("*MapcPlayComplete* Error: %d."), aError); + StopTest(aError, EFail); + } + } + +/** + * + */ +void CAsyncTestMmfAclntAudioPlayerUtil::KickoffTestL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Player Util")); + TPtrC filename1; + TInt repeatCount; + TInt silence; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + INFO_PRINTF1(_L("GetStringFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("numOfRepeat"), repeatCount)) + { + INFO_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + if(!GetIntFromConfig(_L("SectionSilence"), _L("silence"), silence)) + { + INFO_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + iNumOfRepeatsSet = repeatCount; + iSilence = silence; + + GetDriveName(iFileName); + iFileName.Append(filename1); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &iFileName); + iTrigger = CFsmTrigger::NewL(*this); + iPlayer = CMdaAudioPlayerUtility::NewFilePlayerL(iFileName,*this); + iPlayerState = EOpening; + } + +/** + * Time comparison utility function + * + * @param "const TUint aActual" + * The actual timer value produced + * @param "const TUint aExpected" + * Expected timer value + * @param "const TUint aDeviation" + * Allowed deviation of the expected value + * from the actual value. + * @return "TBool" + * Did actual timed value fall within deviation limits + */ +TBool CAsyncTestMmfAclntAudioPlayerUtil::TimeComparison(const TUint aActual, const TUint aExpected, const TUint aDeviation) + { + // save unnessary conditions + if(aActual == aExpected) + return ETrue; + + // Prevent unsigned wrapping errors + TUint difference; + if(aActual > aExpected) + difference = aActual - aExpected; + else + difference = aExpected - aActual; + + // comapare + if(difference < aDeviation) + return ETrue; + return EFalse; + } + +void CAsyncTestMmfAclntAudioPlayerUtil::CloseTest() + { + if (iTrigger) + { + iTrigger->Cancel(); + delete iTrigger; + } + + if (iPlayer) + { + delete iPlayer; + } + } +// +/** + * Implementation of AO timer used to invoke test processing at desired intervals (i.e. State Machine) + **/ + +CFsmTrigger* CFsmTrigger::NewL(CAsyncTestMmfAclntAudioPlayerUtil& aObserver) + { + CFsmTrigger* self = new (ELeave) CFsmTrigger(aObserver); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CFsmTrigger::CFsmTrigger(CAsyncTestMmfAclntAudioPlayerUtil& aObserver) +: CActive(CActive::EPriorityStandard), + iObserver (aObserver) + { + // nothing to do + } + +void CFsmTrigger::ConstructL() + { + User::LeaveIfError (iTimer.CreateLocal()); + CActiveScheduler::Add (this); + } + +CFsmTrigger::~CFsmTrigger() + { + Cancel(); + iTimer.Close(); + } + +void CFsmTrigger::RunL() + { + // need to call Fsm + iObserver.FsmL(); + } + +void CFsmTrigger::DoCancel() + { + iTimer.Cancel(); + } + +void CFsmTrigger::StartTimer(TTimeIntervalMicroSeconds32 aDelay) + { + __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("CFsmTrigger"), 1)); + iTimer.After(iStatus, aDelay); + SetActive(); + } + +//============================================================================================================ +//------------------------------------------------------------------ + +CTestMmfAclntAudioPlayStopStart::CTestMmfAclntAudioPlayStopStart(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioPlayStopStart* CTestMmfAclntAudioPlayStopStart::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioPlayStopStart* self = new (ELeave) CTestMmfAclntAudioPlayStopStart(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioPlayStopStart::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play Stop/Start")); + TVerdict ret = EFail; + + TInt duration = I64INT(aPlayer->Duration().Int64()); + + // Tests pause functionality + aPlayer->Play(); + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + User::After(KTwoSeconds); + INFO_PRINTF1( _L("Stop CMdaAudioPlayerUtility")); + aPlayer->Stop(); + + + User::After(KTwoSeconds); + // only wait for second call to play. + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + + TTime start; + start.HomeTime(); + CActiveScheduler::Start(); + TTime stop; + stop.HomeTime(); + + TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + + + INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"), + iError, I64INT(start.Int64()), I64INT(stop.Int64()), + duration, actualDuration); + if((iError == KErrNone) && + (TimeComparison(actualDuration, duration , KExpectedDeviation))) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +// same as above, but with Pause instead of Stop +CTestMmfAclntAudioPlayPauseStart::CTestMmfAclntAudioPlayPauseStart(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioPlayPauseStart* CTestMmfAclntAudioPlayPauseStart::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioPlayPauseStart* self = new (ELeave) CTestMmfAclntAudioPlayPauseStart(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioPlayPauseStart::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play Pause/Start")); + TVerdict ret = EFail; + + TInt duration = I64INT(aPlayer->Duration().Int64()); + + // Tests pause functionality + // NB we must take the duration from the time at PAUSE, as pause (unlike stop) + // does not reset the clip to start + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + TTime start; + start.HomeTime(); + User::After(KTwoSeconds); + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + INFO_PRINTF1(_L("Pause()"));//Statement Changed under DEF105143 + aPlayer->Pause(); + TTime stop; + stop.HomeTime(); + TUint beforeDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + User::After(KTwoSeconds); + + // wait for second call to play. + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + INFO_PRINTF1(_L("Play()"));//Statement Changed under DEF105143 + aPlayer->Play(); + start.HomeTime(); + CActiveScheduler::Start(); + stop.HomeTime(); + + TUint afterDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + + + INFO_PRINTF7(_L("Error : %d Start = %u Stop = %u Duration = %u ActualDuration = %u + %u"), + iError, I64INT(start.Int64()), I64INT(stop.Int64()), + duration, beforeDuration, afterDuration); + if((iError == KErrNone) && + (TimeComparison(beforeDuration+afterDuration, duration, KExpectedDeviation*2))) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +// Play, pause, play +CTestMmfAclntAudioPlayPausePlayTest::CTestMmfAclntAudioPlayPausePlayTest(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioPlayPausePlayTest* CTestMmfAclntAudioPlayPausePlayTest::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioPlayPausePlayTest* self = new (ELeave) CTestMmfAclntAudioPlayPausePlayTest(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioPlayPausePlayTest::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play-Pause-Play")); + TVerdict ret = EFail; + + // Play #1 + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + User::After(KTwoSeconds); + + // Pause #1 + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + aPlayer->Pause(); + User::After(KTwoSeconds); + + // Play #2 + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + User::After(KOneSecond); + + // Pause #2 + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + aPlayer->Pause(); + User::After(KOneSecond); + + // Play #3 + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + User::After(KOneSecond); + + // Pause #3 + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + aPlayer->Pause(); + User::After(400000); + + // Play #4 + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + CActiveScheduler::Start(); // play to end + + if (iError == KErrNone) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioPlayVolume::CTestMmfAclntAudioPlayVolume(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume,TBool aNegativeTest) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName), iVolume(aVolume) , iNegativeTest(aNegativeTest) + {} + +CTestMmfAclntAudioPlayVolume* CTestMmfAclntAudioPlayVolume::NewL(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume,TBool aNegativeTest) + { + CTestMmfAclntAudioPlayVolume* self = new (ELeave) CTestMmfAclntAudioPlayVolume(aTestName, aSectName, aVolume, aNegativeTest); + return self; + } + + +TVerdict CTestMmfAclntAudioPlayVolume::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play Volume")); + TVerdict ret = EFail; + + + // Check maxvolume function + if(iVolume == -1) + { + INFO_PRINTF1( _L("Volume CHK 1")); + iVolume = aPlayer->MaxVolume(); + INFO_PRINTF2( _L("Volume: Max Volume = %d"),iVolume); + + //on device & emulator KMaxVolume have different values + //if(iVolume != KMaxVolume) // TODO: how to cross ref. this appears to be random values at the moment + // { + // INFO_PRINTF3( _L("Expected volume: %d, received volume : %d"), + // KMaxVolume, iVolume); + + // return EFail; + // } + } + // Volume is truncated to maxvolume + if(iVolume > aPlayer->MaxVolume()) + { + INFO_PRINTF1( _L("Volume CHK 2")); + TInt volume; + INFO_PRINTF2( _L("Volume: SetVolume(%d)"),iVolume); + aPlayer->SetVolume(iVolume); + aPlayer->GetVolume(volume); + INFO_PRINTF2( _L("Volume: GetVolume() returned"),volume); + if(volume == aPlayer->MaxVolume()) + { + ret = EPass; + } + + } + // Volume is truncated to 0 + else if(iVolume < 0) + { + INFO_PRINTF1( _L("Volume CHK 3")); + TInt volume; + INFO_PRINTF2( _L("Volume: SetVolume(%d)"),iVolume); + aPlayer->SetVolume(iVolume); + aPlayer->GetVolume(volume); + INFO_PRINTF2( _L("Volume: GetVolume() returned"),volume); + if(volume == 0) + { + ret = EPass; + } + + } + // Set volume and check + else + { + INFO_PRINTF1( _L("Volume CHK 4")); + INFO_PRINTF2( _L("Volume: SetVolume(%d)"),iVolume); + TInt volume; + aPlayer->SetVolume(iVolume); + aPlayer->GetVolume(volume); + INFO_PRINTF2( _L("Volume: GetVolume() returned"),volume); + if(volume == iVolume) + { + ret = EPass; + } + + else + INFO_PRINTF3( _L("Expected volume: %d, received volume : %d"), iVolume, volume); + + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioRepeat::CTestMmfAclntAudioRepeat(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioRepeat* CTestMmfAclntAudioRepeat::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioRepeat* self = new (ELeave) CTestMmfAclntAudioRepeat(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioRepeat::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Repeats")); + + TVerdict ret = EFail; + TTimeIntervalMicroSeconds silence(0); // silence gap + TInt duration = I64INT(aPlayer->Duration().Int64()); + + aPlayer->SetRepeats(NUMBER_OF_REPEATS,silence); + + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + + TTime start; + start.HomeTime(); + CActiveScheduler::Start(); + TTime stop; + stop.HomeTime(); + + TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + + INFO_PRINTF2( _L("Repeats : %d"), NUMBER_OF_REPEATS); + INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"), + iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration); + if((iError == KErrNone) && (TimeComparison(actualDuration, duration * (NUMBER_OF_REPEATS + 1), + KExpectedDeviation * NUMBER_OF_REPEATS))) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------- + +CTestMmfAclntAudioBalance::CTestMmfAclntAudioBalance(const TDesC& aTestName, const TDesC& aSectName,const TInt aValue, const TInt aExpectedError) + : CTestMmfAclntAudioPlayerUtil(aTestName,aSectName), iBalance(aValue), + iExpectedError(aExpectedError) + {} + +CTestMmfAclntAudioBalance* CTestMmfAclntAudioBalance::NewL(const TDesC& aTestName, const TDesC& aSectName,const TInt aValue, const TInt aExpectedError) + { + CTestMmfAclntAudioBalance* self = new (ELeave) CTestMmfAclntAudioBalance(aTestName,aSectName,aValue, aExpectedError); + return self; + } + +TVerdict CTestMmfAclntAudioBalance::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + TVerdict verdict = EFail; + INFO_PRINTF1( _L("TestPlayerUtils : Audio Balance")); + TInt theErr = KErrNone; + if (iBalance < KMinBalance) + { + theErr = aPlayer->SetBalance(iBalance); + if(theErr != KErrNone) + { + return EFail; + } + + theErr = aPlayer->GetBalance(iBalance); + if(theErr != iExpectedError) + { + return EFail; + } + + INFO_PRINTF2( _L("Test finished with expectable error: %d"), iExpectedError); + return EPass; + } + else if (iBalance > KMaxBalance) + { + theErr = aPlayer->SetBalance(iBalance); + if(theErr != KErrNone) + { + return EFail; + } + + theErr = aPlayer->GetBalance(iBalance); + if(theErr != iExpectedError) + { + return EFail; + } + + + INFO_PRINTF2( _L("Test finished with expectable error: %d"), iExpectedError); + return EPass; + } + else + { + theErr = aPlayer->SetBalance(iBalance); + if(theErr != iExpectedError) + { + return EFail; + } + + theErr = aPlayer->GetBalance(iBalance); + if(theErr != iExpectedError) + { + return EFail; + } + + + INFO_PRINTF2( _L("Test finished with expectable error: %d"), iExpectedError); + verdict = EPass; + } + return verdict; + } + +CTestMmfAclntAudioDuration::CTestMmfAclntAudioDuration(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioDuration* CTestMmfAclntAudioDuration::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioDuration* self = new (ELeave) CTestMmfAclntAudioDuration(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioDuration::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Duration")); + TVerdict ret = EFail; + if (iDuration == aPlayer->Duration()) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +CDelayedMethodCall* CDelayedMethodCall::NewL(MDelayedMethodCall* aThat) + { + __ASSERT_ALWAYS(aThat, User::Leave(KErrArgument)); + CDelayedMethodCall* self = new (ELeave) CDelayedMethodCall(aThat); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + }; + + +void CDelayedMethodCall::RunL() + { + iThat->DelayedMethodCallL(); + } + +TInt CDelayedMethodCall::RunError(TInt aError) + { + RDebug::Print( _L("CDelayedMethodCall::RunL Left %d\n"), aError); + return KErrNone; + } + + +CDelayedMethodCall::CDelayedMethodCall(MDelayedMethodCall* aThat) : CTimer(0), iThat(aThat) + { + CActiveScheduler::Add(this); + } + + + +//------------------------------------------------------------------ +/** + * Constructor + */ +CTestMmfAclntPriority::CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority) + { + // store the name of this test case + // this is the name that is used by the script file +// Each test step initialises it's own name + iTestStepName = aTestName; + iPriority = aPriority; + iPriorityManual = ETrue; + iSectName = aSectName; + } + +CTestMmfAclntPriority* CTestMmfAclntPriority::NewL(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority) + { + CTestMmfAclntPriority* self = new (ELeave) CTestMmfAclntPriority(aTestName, aSectName, aPriority); + return self; + } + +// overridden constructor for no priority setting +CTestMmfAclntPriority::CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iPriority = EMdaPriorityNormal; + iPriorityManual = EFalse; + iSectName = aSectName; + } + + +CTestMmfAclntPriority* CTestMmfAclntPriority::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntPriority* self = new (ELeave) CTestMmfAclntPriority(aTestName, aSectName); + return self; + } + +void CTestMmfAclntPriority::MchoComplete(TInt aID, TInt aError) + { + INFO_PRINTF3( _L("Callback for CMdaAudioPlayerUtility called : ID %d, error %d"), aID, aError); + + iError = aError; + + iCallbackError[aID] = aError; + + + if(iFirstCallback == -1) + { + iFirstCallback = aID; + } + + + if((--iCallbackCount) <= 0) + { + CActiveScheduler::Stop(); + } + + } + + +//This method is used to start playing file 0 after file 1 has started +void CTestMmfAclntPriority::DelayedMethodCallL() +{ + audioUtil[0]->Play(); + if(iError == KErrNone) + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility 0")); + } +} + + + + +/** + * Audio priority. + */ +TVerdict CTestMmfAclntPriority::DoTestStepL() + { + INFO_PRINTF1( _L("TestPlayerUtils : Priority")); + + TBuf filename0, filename1; + + TPtrC file; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), file)) + { + return EInconclusive; + } + + GetDriveName(filename0); + filename0.Append(file); + + if(!GetStringFromConfig(iSectName, _L("playerAudioFile2"), file)) + { + return EInconclusive; + } + + GetDriveName(filename1); + filename1.Append(file); + + TVerdict ret=EFail; + + CPlayerCallbackHandler* callback[2]; + + iError = KErrNone; + + for(TInt i=0; i<2; i++) + { + callback[i] = new (ELeave) CPlayerCallbackHandler(i,this); + CleanupStack::PushL(callback[i]); + } + + + audioUtil[0] = CMdaAudioPlayerUtility::NewFilePlayerL(filename0,*callback[0],EMdaPriorityNormal); + CleanupStack::PushL(audioUtil[0]); + audioUtil[1] = CMdaAudioPlayerUtility::NewFilePlayerL(filename1,*callback[1],EMdaPriorityNormal); + CleanupStack::PushL(audioUtil[1]); + + INFO_PRINTF2( _L("Initialise CMdaAudioPlayerUtility 0 - %S"), &filename0); + INFO_PRINTF2( _L("Initialise CMdaAudioPlayerUtility 1 - %S"), &filename1); + + iCallbackCount = 2; + // wait for initilisation callback + CActiveScheduler::Start(); + + if(iError == KErrNone && iCallbackCount == 0) + { + // set manual priority on audioUtil[0] ? + if(iPriorityManual) + { + TInt priErr = audioUtil[0]->SetPriority(iPriority, EMdaPriorityPreferenceNone); + INFO_PRINTF3(_L("Priority set manually to %d - return %d"), iPriority, priErr); + } + + audioUtil[1]->Play(); + if(iError == KErrNone) + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility 1")); + } + + iCallbackCount = 2; + iFirstCallback = -1; + + CDelayedMethodCall* delayedMethodCall = CDelayedMethodCall::NewL(this); + CleanupStack::PushL(delayedMethodCall); + delayedMethodCall->After(KOneSecond); + + // wait for play to complete + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + CleanupStack::PopAndDestroy(delayedMethodCall); //delayedMethodCall + + if(iError == KErrNone && iCallbackCount == 0) + { + if( ((iPriority < EMdaPriorityNormal) && (iFirstCallback == 0 ) && (iCallbackError[0]==KErrInUse) && (iCallbackError[1]==KErrNone)) || + ((iPriority == EMdaPriorityNormal) && (iFirstCallback == 0 ) && (iCallbackError[0]==KErrInUse) && (iCallbackError[1]==KErrNone)) || + ((iPriority > EMdaPriorityNormal) && (iFirstCallback == 1 ) && (iCallbackError[0]==KErrNone) && (iCallbackError[1]==KErrInUse)) + ) + { + ret = EPass; + } + INFO_PRINTF2( _L("First callback with Id: %d"), iFirstCallback); + INFO_PRINTF3( _L("Error codes - file 0 = %d file 1 = %d"), iCallbackError[0], iCallbackError[1]); + } + } + + if(iError != 0) + { + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError ); + } + + + CleanupStack::PopAndDestroy(4); // audioUtil , callback + + User::After(KOneSecond); + return ret; + } + + + +//------------------------------------------------------------------ + +CTestMmfAclntAudioPosition::CTestMmfAclntAudioPosition(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition) + : CTestMmfAclntAudioPlayerUtil(aTestName,aSectName), iPosition(aPosition) + {} + +CTestMmfAclntAudioPosition* CTestMmfAclntAudioPosition::NewL(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition) + { + CTestMmfAclntAudioPosition* self = new (ELeave) CTestMmfAclntAudioPosition(aTestName,aSectName,aPosition); + return self; + } + +TVerdict CTestMmfAclntAudioPosition::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Position")); + TVerdict ret = EFail; + TTimeIntervalMicroSeconds position; + TBool validPosition = EFalse; + INFO_PRINTF3(_L("Set Position %d Duration = %d"), + I64INT(iPosition.Int64()), I64INT(aPlayer->Duration().Int64())); + + // Set position: middle of clip. + if (I64INT(iPosition.Int64()) == 0) + { + iPosition = I64INT(aPlayer->Duration().Int64())/2; + } + + // Set position: end of clip. + if (I64INT(iPosition.Int64()) == -1) + { + iPosition = aPlayer->Duration(); + } + + // Position is beyond the end of the clips duration. + // so check that the value is clipped. + if(aPlayer->Duration() < iPosition) + { + aPlayer->SetPosition(iPosition); + + //aPlayer->Play(); // Playing the clip will reset the position to 0 when finished. + //CActiveScheduler::Start(); + + /*TInt theRes1 = */aPlayer->GetPosition(position); + + + INFO_PRINTF2(_L("Longer than duration : Setting position to %d"), I64INT(iPosition.Int64())); + INFO_PRINTF3(_L("Set : position = %d (if clipped : %d)"), + I64INT(position.Int64()), I64INT(aPlayer->Duration().Int64())); + + TInt theRes = aPlayer->GetPosition(position); + if(theRes == KErrNone && (position.Int64() == aPlayer->Duration().Int64())) + { + validPosition = ETrue; + } + } + + + // Position is before the end of the clips duration. + // so check that the value is clipped to 0 + // *** added by JW after discussion re. expected behaviour - + // for test 1009 + else if(iPosition < TTimeIntervalMicroSeconds(0)) + { + aPlayer->SetPosition(iPosition); + + aPlayer->Play(); + CActiveScheduler::Start(); + + /*TInt theRes1 = */aPlayer->GetPosition(position); + + + INFO_PRINTF2(_L("Shorter than 0 : Setting position to %d"), I64INT(iPosition.Int64())); + INFO_PRINTF2(_L("Set : position = %d (if clipped : 0)"), + I64INT(position.Int64())); + + TInt theRes = aPlayer->GetPosition(position); + if(theRes == KErrNone && I64INT(position.Int64()) == 0) + { + validPosition = ETrue; + } + + } + + else + { + + aPlayer->SetPosition(iPosition); + aPlayer->GetPosition(position); + INFO_PRINTF3(_L("Set : position = %d, duration = %d)"), + I64INT(position.Int64()), I64INT(aPlayer->Duration().Int64())); + aPlayer->Play(); + + CActiveScheduler::Start(); + + // For test 1009, we check that the expected error code was returned + // *** removed by JW after discussion re. expected behaviour + /* + if (iPosition < TTimeIntervalMicroSeconds(0)) + { + TVerdict ret = EFail; + if (iError == KErrArgument) + { + if (position != TTimeIntervalMicroSeconds(0)) + { + INFO_PRINTF2(_L("ERROR: KErrArgument returned, but position was %d, expected position = 0"),position); + ret = EFail; + } + else + { + // Test passed + ret = EPass; + } + } + else + { + INFO_PRINTF3(_L("Expected error not returned, expecting %d, got %d"), KErrArgument, iError); + ret = EFail; + } + return ret; + } + */ + + aPlayer->Stop(); + + //TInt64 temp = (iPosition.Int64() / KPcm16FrameInterval) - 1; // -1 for DevSound + aPlayer->GetPosition(position); + // returned position should equal the original position or number of frames * frame intervals. + // The above comment is invalid, one the clip has played the position should be reset to 0. - INC24264 + if (position.Int64() == 0) + //if(position.Int64() == (temp * KPcm16FrameInterval) || (position == iPosition)) + { + validPosition = ETrue; + } + //else + INFO_PRINTF3( _L("Expected position : %f, received position : %f"), + I64REAL(iPosition.Int64()), I64REAL(position.Int64())); + } + + // Postion was set to a valid value. + if(validPosition) + { + aPlayer->Play(); + // wait for play to complete + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + INFO_PRINTF2( _L("Error : %d"), iError); + if (iError == KErrNone) + ret = EPass; + } + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioPlayWindow::CTestMmfAclntAudioPlayWindow(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName), iNegative(aNegative) + {} + +CTestMmfAclntAudioPlayWindow* CTestMmfAclntAudioPlayWindow::NewL(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative) + { + CTestMmfAclntAudioPlayWindow* self = new (ELeave) CTestMmfAclntAudioPlayWindow(aTestName, aSectName, aNegative); + return self; + } + +TVerdict CTestMmfAclntAudioPlayWindow::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play Window")); + TVerdict ret = EFail; + TInt64 temp1, temp2; + TInt duration = I64INT(aPlayer->Duration().Int64()); + + TInt windowDuration = 0; + if(iNegative) + { + INFO_PRINTF1( _L("Attempting to set an invalid play window")); + temp1 = -KInvalidNumber; + temp2 = aPlayer->Duration().Int64() + KInvalidNumber; + windowDuration = I64INT(aPlayer->Duration().Int64()); + } + else + { + temp1 = aPlayer->Duration().Int64()/2; + temp2 = aPlayer->Duration().Int64(); + + windowDuration = (I64INT(temp2) - I64INT(temp1)); + } + + + TTimeIntervalMicroSeconds startTime(temp1); + TTimeIntervalMicroSeconds endTime(temp2); + + INFO_PRINTF4(_L("StartTime = %d EndTime = %d WindowDuration = %d"), + I64INT(startTime.Int64()), I64INT(endTime.Int64()), windowDuration); + + TInt windowSet = aPlayer->SetPlayWindow(startTime,endTime); + + if (iNegative && (windowSet == KErrArgument)) + { + INFO_PRINTF1( _L("Correct return from SetPlayWindow (KErrArgument) when attempting to set an invalid window range")); + return EPass; + } + + if (windowSet != KErrNone) + { + INFO_PRINTF2( _L("Unexpected error returned from SetPlayWindow - %d"),windowSet); + return EFail; + } + + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + + TTime start; + start.HomeTime(); + CActiveScheduler::Start(); + TTime stop; + stop.HomeTime(); + + TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + + INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d WindowDuration = %d ActualDuration = %d"), + iError, I64INT(start.Int64()), I64INT(stop.Int64()), windowDuration, actualDuration); + + if((iError == KErrNone) && (TimeComparison(actualDuration, windowDuration, KExpectedDeviation))) + { + aPlayer->ClearPlayWindow(); + + iError = KErrTimedOut; + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + aPlayer->Play(); + + TTime start; + start.HomeTime(); + CActiveScheduler::Start(); + TTime stop; + stop.HomeTime(); + + TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64()); + + INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"), + iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration); + ret = EPass; + } + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioType::CTestMmfAclntAudioType(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioType* CTestMmfAclntAudioType::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioType* self = new (ELeave) CTestMmfAclntAudioType(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioType::DoTestL(CMdaAudioPlayerUtility* /*aPlayer*/) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Type")); + INFO_PRINTF1( _L("#######################################################")); + INFO_PRINTF1( _L("No Audio Type API call for class CMdaAudioPlayerUtility")); + INFO_PRINTF1( _L("This test is therefore inconclusive.")); + INFO_PRINTF1( _L("#######################################################")); + TVerdict ret = EInconclusive; + + // what code should/might look like. + //CMdaAudioType* type = aPlayer->TypeL(); + + // CMdaAudioType class incomplete: + // TODO check data returned is valid??? + + return ret; + } + +//-------------------------------------------------------------- + +CTestMmfAclntAudioRamp::CTestMmfAclntAudioRamp(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioRamp* CTestMmfAclntAudioRamp::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioRamp* self = new (ELeave) CTestMmfAclntAudioRamp(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioRamp::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Ramp")); + TVerdict ret = EFail; + TTimeIntervalMicroSeconds ramp(100); + aPlayer->SetVolumeRamp(ramp); + + aPlayer->Play(); + // wait for open to complete + iError = KErrTimedOut; + CActiveScheduler::Start(); + if(iError == KErrNone) + ret = EPass; + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioMeta::CTestMmfAclntAudioMeta(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioMeta* CTestMmfAclntAudioMeta::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioMeta* self = new (ELeave) CTestMmfAclntAudioMeta(aTestName, aSectName); + return self; + } + +_LIT(name,"Title"); +_LIT(data,"Symbian"); +TVerdict CTestMmfAclntAudioMeta::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Metadata")); + + TInt numEntries; + TInt theErr = aPlayer->GetNumberOfMetaDataEntries(numEntries); + INFO_PRINTF3(_L("Error : %d NumEntries : %d"), theErr, numEntries); + + if(theErr && theErr != KErrNotSupported) // Audio Controller doesn't support - this is ok + { + ERR_PRINTF2(_L("GetNumberOfMetaDataEntries returned unexpected error %d"), theErr); + return EFail; + } + + CMMFMetaDataEntry* testData = NULL; + + TRAPD(theErr2, testData = aPlayer->GetMetaDataEntryL(0)); + if(!theErr2) + { + if((testData->Name() == name) && (testData->Value() == data)) + return EPass; + } + else + { + if(theErr == KErrNotSupported) // Audio Controller doesn't support - this is ok + { + INFO_PRINTF1(_L("Note : Audio Controller does not support metadata")); + return EPass; + } + else if(numEntries == 0) + { + INFO_PRINTF1(_L("No metadata entries found")); + return EPass; + } + else + { + ERR_PRINTF2(_L("GetMetaDataEntryL left with unexpected error %d"), theErr2); + return EFail; + } + } + return EPass; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioCloseOpen::CTestMmfAclntAudioCloseOpen(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioCloseOpen* CTestMmfAclntAudioCloseOpen::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioCloseOpen* self = new (ELeave) CTestMmfAclntAudioCloseOpen(aTestName, aSectName); + return self; + } + + + + +TVerdict CTestMmfAclntAudioCloseOpen::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Close/Open")); + + TVerdict ret = EFail; + aPlayer->Close(); + + // get second file name + TBuf filename2; + TPtrC filename; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename)) + { + return EInconclusive; + } + + GetDriveName(filename2); + filename2.Append(filename); + + // Open second file + aPlayer->OpenFileL(filename2); + // wait for open to complete + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + TInt openErr = iError; + + INFO_PRINTF2( _L("OpenFileL completed with error %d"), iError); + + if (iError == KErrNone && openErr == KErrNone) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntAudioBitRate::CTestMmfAclntAudioBitRate(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iKeyFileName = aKeyName1; + iKeyBitRateName = aKeyName2; + } + +CTestMmfAclntAudioBitRate* CTestMmfAclntAudioBitRate::NewL(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2) + { + CTestMmfAclntAudioBitRate* self = new (ELeave) CTestMmfAclntAudioBitRate(aTestName,aKeyName1,aKeyName2); + return self; + } + +void CTestMmfAclntAudioBitRate::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds & /*aDuration*/) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntAudioBitRate::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntAudioBitRate::DoTestStepL( void ) + { + + INFO_PRINTF1( _L("TestPlayerUtils : Audio Bit Rate")); + + iError = KErrTimedOut; + TUint bitRate = 0; + TVerdict res = EFail; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(_L("SectionNine"),iKeyFileName,filename1)) + { + return EInconclusive; + } + if(!GetIntFromConfig(_L("SectionNine"),iKeyBitRateName,iExpectedBitRate)) + { + return EInconclusive; + } + + INFO_PRINTF2(_L("Expected bit rate: %d"), iExpectedBitRate); + + GetDriveName(filename); + filename.Append(filename1); + + CMdaAudioPlayerUtility* player = CMdaAudioPlayerUtility::NewFilePlayerL(filename1,*this); + CleanupStack::PushL(player); + CActiveScheduler::Start(); + + if (iError == KErrNone) + { + player->Play(); + CActiveScheduler::Start(); + if(iError == KErrNone) + { + TInt err = player->GetBitRate(bitRate); + if(err == KErrNone) + { + INFO_PRINTF2(_L("Retrieved bit rate: %d"), bitRate); + if(static_cast(bitRate) == iExpectedBitRate) + { + INFO_PRINTF1(_L("The Expected bit rate and retrieved bit rate matched")); + res = EPass; + } + else + { + INFO_PRINTF1(_L("The Expected bit rate and retrieved bit rate does not match")); + } + } + else + { + INFO_PRINTF2(_L("Failed with error %d while getting the bit rate"), err); + } + } + else + { + INFO_PRINTF1(_L("Failed during playing the audio")); + } + } + else + { + INFO_PRINTF2(_L("Failed during opening the file. Error = %d "), iError); + } + CleanupStack::PopAndDestroy(player); + return res; + } + + +//------------------------------------------------------------------ +CTestMmfAclntAudioQuery::CTestMmfAclntAudioQuery(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntAudioQuery* CTestMmfAclntAudioQuery::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntAudioQuery* self = new (ELeave) CTestMmfAclntAudioQuery(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntAudioQuery::DoTestL(CMdaAudioPlayerUtility* /*aPlayer*/) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Query")); + + TVerdict ret = EFail; + + // enhanced - to use CMMFControllerPluginSelectionParameters + + INFO_PRINTF1(_L("Querying play formats...")); + + CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC(); + CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC(); + + RArray mediaIds; + mediaIds.Append(KUidMediaTypeAudio); + cSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOtherMediaIds); + cSelect->SetRequiredPlayFormatSupportL(*fSelect); + + RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data + CleanupResetAndDestroyPushL(controllers); + cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers + TInt numControllers = controllers.Count(); + if(!numControllers) + { + ERR_PRINTF1(_L("Could not find any controllers")); + } + else + { + INFO_PRINTF2(_L("Found %d controllers"), numControllers); + for(int i = 0; i < numControllers; i++) + { + RMMFFormatImplInfoArray cFormats = controllers[i]->PlayFormats(); + const CDesC8Array* fileExtensions = &cFormats[0]->SupportedMimeTypes(); + INFO_PRINTF3(_L("- Controller: %d Extensions : %d"), i, fileExtensions->Count()); + for(int j = 0; j < fileExtensions->Count(); j++) + { + TBuf<24> ext16; + ext16.Copy(fileExtensions->MdcaPoint(j)); + INFO_PRINTF2(_L("-- %S"), &ext16); + } + } + ret = EPass; + } + + CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect + + return ret; + } + +//-------------------------------------------------------------------- + +// Negative tests + +//-------------------------------------------------------------------- + +/** + * Constructor + */ +CTestMmfAclntNoLoad::CTestMmfAclntNoLoad(const TDesC& aTestName, const TDesC& aSectName) + :CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + { + } + +CTestMmfAclntNoLoad* CTestMmfAclntNoLoad::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntNoLoad* self = new (ELeave) CTestMmfAclntNoLoad(aTestName, aSectName); + return self; + } + +TVerdict CTestMmfAclntNoLoad::DoTestL(CMdaAudioPlayerUtility* /*aPlayer*/) + { + return EPass; + } + +/** + * Play with no loaded sound file. + */ +TVerdict CTestMmfAclntNoLoad::DoTestStepL() + { + INFO_PRINTF1( _L("TestPlayerUtils : No Load")); + + iError = KErrTimedOut; + iStop = ETrue; + + CMdaAudioPlayerUtility* player = CMdaAudioPlayerUtility::NewL(*this); + CleanupStack::PushL(player); + player->Play(); + + CActiveScheduler::Start(); + + if(iError == KErrNotReady) + { + CleanupStack::PopAndDestroy(player); + return EPass; + } + + ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d (expected KErrNotReady)"),iError ); + CleanupStack::PopAndDestroy(player); + return EFail; + } + +//------------------------------------------------------------------ + +CTestMmfAclntDeletePlay::CTestMmfAclntDeletePlay(const TDesC& aTestName, const TDesC& aSectName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName) + {} + +CTestMmfAclntDeletePlay* CTestMmfAclntDeletePlay::NewL(const TDesC& aTestName, const TDesC& aSectName) + { + CTestMmfAclntDeletePlay* self = new (ELeave) CTestMmfAclntDeletePlay(aTestName, aSectName); + return self; + } + + + +/** + * Audio clip - Delete object before play operation has completed. + */ +TVerdict CTestMmfAclntDeletePlay::DoTestL(CMdaAudioPlayerUtility* /*aPlayer*/) + { + INFO_PRINTF1( _L("TestPlayerUtils : Delete/Play")); + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + iError = KErrTimedOut; + __MM_HEAP_MARK; + + CMdaAudioPlayerUtility* player = CMdaAudioPlayerUtility::NewFilePlayerL(filename,*this); + CleanupStack::PushL(player); + // wait for open to complete + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + player->Play(); + CleanupStack::PopAndDestroy(player); // destroy player before play has completed + __MM_HEAP_MARKEND; + User::Heap().Check(); + return EPass; + } + + CleanupStack::PopAndDestroy(player); + ERR_PRINTF2( _L("CMdaAudioRecorderUtility failed with error %d"),iError ); + __MM_HEAP_MARKEND; + return EFail; + } + +//------------------------------------------------------------------ + +CTestMmfAclntPlayPlay::CTestMmfAclntPlayPlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CTestMmfAclntAudioPlayerUtil(aTestName, aSectName), iKeyName(aKeyName) + {} + +CTestMmfAclntPlayPlay* CTestMmfAclntPlayPlay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + CTestMmfAclntPlayPlay* self = new (ELeave) CTestMmfAclntPlayPlay(aTestName, aSectName, aKeyName); + return self; + } + + +/** + * Open new file while audio player is playing. + */ +TVerdict CTestMmfAclntPlayPlay::DoTestL(CMdaAudioPlayerUtility* aPlayer) + { + INFO_PRINTF1( _L("TestPlayerUtils : Play/Play")); + + TVerdict ret = EFail; + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + //if(!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), filename1)) + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + aPlayer->Play(); + + + TInt error = KErrNone; + TRAP(error,aPlayer->OpenFileL(filename)); + // wait for open to complete + CActiveScheduler::Start(); + aPlayer->Play(); + CActiveScheduler::Start(); + + if(error == KErrNone) + ret = EPass; + + return ret; + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntCorruptDes::CTestMmfAclntCorruptDes(const TDesC& aTestName,const TDesC& aSectName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + } + +void CTestMmfAclntCorruptDes::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &/*aDuration*/) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete")); + CActiveScheduler::Stop(); + } + +void CTestMmfAclntCorruptDes::MapcPlayComplete(TInt aError) + { + iError = aError; + INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete")); + CActiveScheduler::Stop(); + } + + + +TVerdict CTestMmfAclntCorruptDes::DoTestStepPreambleL() + { + RFs fs; + RFile file; + TInt size = 0; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + INFO_PRINTF2( _L("File under test - %S"), &filename); + + User::LeaveIfError(file.Size(size)); + INFO_PRINTF2(_L("size of file = %d\n"),size);//Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(size); + // Buffer has not been init with data. + CleanupStack::PopAndDestroy(); //file + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntCorruptDes::DoTestStepPostambleL() + { + delete iAudio; + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * Play using a corrupt descriptor. + */ +TVerdict CTestMmfAclntCorruptDes::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Corrupt Des")); + iError = KErrTimedOut; + + TPtr8 bufferDes(iAudio->Des()); + CMdaAudioPlayerUtility * player = CMdaAudioPlayerUtility::NewDesPlayerL(bufferDes, *this); + CleanupStack::PushL(player); + + // Wait for init callback + INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility")); + CActiveScheduler::Start(); + + if (iError == KErrBadDescriptor || iError == KErrNotSupported) + { + CleanupStack::PopAndDestroy(player); + return EPass; + } + if (iError == KErrNone) + { + iError = KErrTimedOut; + player->Play(); + // wait for play. + if (iError == KErrNone) + { + CleanupStack::PopAndDestroy(player); + return EPass; + } + } + CleanupStack::PopAndDestroy(player); + return EFail; + } + +// +//============================================================================================= +// + +CAsyncTestMmfAclntAudioRepeatPlayPausePlay* CAsyncTestMmfAclntAudioRepeatPlayPausePlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayPausePlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatPlayPausePlay::CAsyncTestMmfAclntAudioRepeatPlayPausePlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioRepeatPlayPausePlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/Play/Pause/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Trailing silence = %ld\n"),iSilence.Int64()); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime();// start the timer + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Call Pause for this test case after two sec + iTestState = EStatePause; + } + else if(iPlayerState == EPaused || iPlayerState == EStopped ) + { + iPlayer->Play(); + iStart.HomeTime();// start the timer for resuming playback + iPlayerState = EPlaying; + } + break; + } + case EStatePause: + { + if(iPlayerState == EPlaying) + { + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + iPlayer->Pause(); + iStop.HomeTime(); + + iPausedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Resume after two seconds + iPlayerState = EPaused; + iTestState = EStatePlay; + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iResumedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + iActualDuration = iPausedDuration + iResumedDuration; + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + 2*KExpectedDeviation))//more because of the latency during pausing + { + StopTest(); // success + break; + } + else + { + STOP_TEST_GEN_ERROR; + break; + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + 2*iNumOfRepeatsSet*KExpectedDeviation)) + { + StopTest(); // success + break; + } + else + { + STOP_TEST_GEN_ERROR; + break; + } + #endif + } + else // In case of .sqn file there will be no duration + { + StopTest(); + break; + } + } + + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay* CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay( aTestName, aSectName, aKeyName, aPosition); + } + +CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay::CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName), iPosition(aPosition) + { + } + +void CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/Reposition/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime();// start the timer + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call Setposition for this test case after two sec + iTestState = EStateSetPosition; + } + break; + } + case EStateSetPosition: + { + if(iPlayerState == EPlaying) + { + INFO_PRINTF1( _L("SetPosition CMdaAudioPlayerUtility")); + iPlayer->SetPosition(iPosition); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iResumedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + iActualDuration = iPausedDuration + iResumedDuration; + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, (iDuration * (iNumOfRepeatsSet + 1))+1, + 2*KExpectedDeviation))//more because of the latency during repositioning + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, (iDuration * (iNumOfRepeatsSet + 1))+1, + 2*iNumOfRepeatsSet*KExpectedDeviation))//more because of the latency during repositioning + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else // In case of .sqn file there will be no duration + { + StopTest(); + break; + } + + } + + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + +CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay* CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay::CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/Play/Pause/Repeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet ); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Call Pause for this test case after two sec + iTestState = EStatePause; + } + else if(iPlayerState == EPaused || iPlayerState == EStopped ) + { + iPlayer->Play(); // wait till play completes + iStart.HomeTime();// start the timer after resuming playback + iPlayerState = EPlaying; + } + break; + } + case EStatePause: + { + if(iPlayerState == EPlaying) + { + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + iPlayer->Pause(); + iStop.HomeTime(); + + iPausedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + //Now Set New Repeat Value + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("newRepeatValue"), iNumOfRepeatsSet)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Resume after two seconds + iPlayerState = EPaused; + iTestState = EStatePlay; + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iResumedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + iActualDuration = iPausedDuration + iResumedDuration; + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation * 2))//more because of latency during Pausing + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation * 2*iNumOfRepeatsSet))//more because of latency during Pausing + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + + + default: + ERR_PRINTF1(_L("State machine error")); + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + +CAsyncTestMmfAclntAudioPlayPauseRepeatPlay* CAsyncTestMmfAclntAudioPlayPauseRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayPauseRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayPauseRepeatPlay::CAsyncTestMmfAclntAudioPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayPauseRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/Pause/Repeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call Pause for this test case after two sec + iTestState = EStatePause; + } + else if(iPlayerState == EPaused || iPlayerState == EStopped ) + { + iPlayer->Play(); // wait till play completes + iStart.HomeTime();//start the timer after resuming playback + + iPlayerState = EPlaying; + } + break; + } + case EStatePause: + { + if(iPlayerState == EPlaying) + { + INFO_PRINTF1(_L("Pause CMdaAudioPlayerUtility")); + iPlayer->Pause(); + iStop.HomeTime(); + + iPausedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + + iPlayerState = EPaused; + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Resume after one seconds + iTestState = EStatePlay; + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iResumedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + iActualDuration = iPausedDuration + iResumedDuration; + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation * 2))//more because of latency during pausing + { + StopTest(); // success + break; + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation *iNumOfRepeatsSet* 2))//more because of latency during pausing + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + +CAsyncTestMmfAclntAudioPlayRepeat* CAsyncTestMmfAclntAudioPlayRepeat::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayRepeat( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayRepeat::CAsyncTestMmfAclntAudioPlayRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayRepeat::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/Repeat")); + iDuration = I64INT(iPlayer->Duration().Int64()); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime();// Start the timer + + TTimeIntervalMicroSeconds silence(0); // silence gap + INFO_PRINTF1( _L("SetRepeats with higher value CMdaAudioPlayerUtility")); + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("maxRepeatValue"), iNumOfRepeatsSet)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + break; + } + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation)) + { + StopTest(); // success + } + else + { + if(TimeComparison(iActualDuration, (iDuration + 100000) * (iNumOfRepeatsSet + 1), + KExpectedDeviation)) + { + StopTest(KErrGeneral, EKnownFailure); + } + else + { + STOP_TEST_GEN_ERROR; + } + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + +CAsyncTestMmfAclntAudioRepeatBeforeOpen* CAsyncTestMmfAclntAudioRepeatBeforeOpen::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatBeforeOpen( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatBeforeOpen::CAsyncTestMmfAclntAudioRepeatBeforeOpen( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioRepeatBeforeOpen::KickoffTestL( void ) + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Player Util")); + TPtrC filename1; + TInt repeatCount; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + ERR_PRINTF1(_L("GetStringFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("numOfRepeat"), repeatCount)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + iNumOfRepeatsSet = repeatCount; + GetDriveName(iFileName); + iFileName.Append(filename1); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &iFileName); + iTrigger = CFsmTrigger::NewL(*this); + + iPlayer = CMdaAudioPlayerUtility::NewL(*this); + + TTimeIntervalMicroSeconds trailingSilence(1); + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility before opening the clip")); + iNumOfRepeatsSet = NUMBER_OF_REPEATS; + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,trailingSilence); + iPlayer->OpenFileL(iFileName); + iPlayerState = EOpening; + } + +void CAsyncTestMmfAclntAudioRepeatBeforeOpen::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime();// Start the timer + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + +CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay* CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay::CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/Repeat/Pause/Repeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStateSetRepeat: + { + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond);// Call Pause after two seconds + iTestState = EStatePause; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateSetRepeat; + } + else if(iPlayerState == EPaused || iPlayerState == EStopped ) + { + iPlayer->Play(); // wait till play completes + iStart.HomeTime(); + iPlayerState = EPlaying; + } + break; + } + case EStatePause: + { + if(iPlayerState == EPlaying) + { + INFO_PRINTF1( _L("Pause CMdaAudioPlayerUtility")); + iPlayer->Pause(); + iStop.HomeTime(); + iPausedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + + //Now Set New Repeat Value + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("newRepeatValue"), iNumOfRepeatsSet)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + break; + } + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Resume after two seconds + iPlayerState = EPaused; + iTestState = EStatePlay; + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iResumedDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + iActualDuration = iPausedDuration + iResumedDuration; + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation * 2)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration * (iNumOfRepeatsSet + 1), + KExpectedDeviation * iNumOfRepeatsSet* 2)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + +CAsyncTestMmfAclntAudioRepeatPlayStopPlay* CAsyncTestMmfAclntAudioRepeatPlayStopPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayStopPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatPlayStopPlay::CAsyncTestMmfAclntAudioRepeatPlayStopPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioRepeatPlayStopPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/Play/Stop/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iStart.HomeTime(); + + iPlayerState = EPlaying; + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call Stop for this test case after two sec + iTestState = EStateStop; + } + else if(iPlayerState == EPaused || iPlayerState == EStopped ) + { + iPlayer->Play(); // wait till play completes + iStart.HomeTime(); + iPlayerState = EPlaying; + } + break; + } + case EStateStop: + { + INFO_PRINTF1( _L("Stop CMdaAudioPlayerUtility")); + iPlayer->Stop(); + iPlayerState = EStopped; + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KTwoSeconds); // Call Pause for this test case after two sec + iTestState = EStatePlay; + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration*(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration*(iNumOfRepeatsSet+1), KExpectedDeviation)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration*(iNumOfRepeatsSet+1), KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); + break; + } + } + + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + +CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay* CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay::CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/Play/Repeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("newRepeatValue"), iNumOfRepeatsSet)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + break; + } + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet ); + iPlayer->SetRepeats(iNumOfRepeatsSet, iSilence); + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1), + KExpectedDeviation)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1), + KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + + +CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay* CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay::CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/Repeat/Repeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("newRepeatValue"), iNumOfRepeatsSet)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + break; + } + INFO_PRINTF2( _L("Repeats = %d"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1),KExpectedDeviation)) + // since we setting repeats during first playback of first repeat, we need to take into consideration of first playback + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1),KExpectedDeviation*iNumOfRepeatsSet)) + // since we setting repeats during first playback of first repeat, we need to take into consideration of first playback + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + + +CAsyncTestMmfAclntAudioPlayRepeatRamp* CAsyncTestMmfAclntAudioPlayRepeatRamp::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayRepeatRamp( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayRepeatRamp::CAsyncTestMmfAclntAudioPlayRepeatRamp( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayRepeatRamp::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/SetVolumeRamp/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("SetVolumeRamp CMdaAudioPlayerUtility")); + iPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(5000000)); + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration *(iNumOfRepeatsSet+1)); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1), + KExpectedDeviation)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iDuration *(iNumOfRepeatsSet+1), + KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); // success + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } +//============================================================================================================ + +CAsyncTestMmfAclntAudioRepeatForeverPlay* CAsyncTestMmfAclntAudioRepeatForeverPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatForeverPlay( aTestName, aSectName, aKeyName, aTrailingSilence); + } + +CAsyncTestMmfAclntAudioRepeatForeverPlay::CAsyncTestMmfAclntAudioRepeatForeverPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + iTrailingSilence = aTrailingSilence; + } + +void CAsyncTestMmfAclntAudioRepeatForeverPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio RepeatForever/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats (KMdaRepeatForever) = %d\n"),KMdaRepeatForever); + INFO_PRINTF2( _L("Trailing silence = %ld\n"),iTrailingSilence.Int64()); + iPlayer->SetRepeats(KMdaRepeatForever,iTrailingSilence); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + if(iDuration) + { + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(iDuration * 6); // Wait till complettion of 5 repeats then issue stop + } + else + { + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond * 40); // Wait for 40 sec of playback and then issue stop + } + iTestState = EStateStop; + } + break; + } + case EStateStop: + { + INFO_PRINTF1( _L("Stop CMdaAudioPlayerUtility")); + iPlayer->Stop(); + iPlayerState = EStopped; + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); // Call Pause for this test case after two sec + iTestState = EStateStopTest; + break; + } + case EStateStopTest: + { + StopTest(); // success + break; + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + + +//============================================================================================================ + +CAsyncTestMmfAclntAudioRepeatPlayGetPosition* CAsyncTestMmfAclntAudioRepeatPlayGetPosition::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioRepeatPlayGetPosition( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioRepeatPlayGetPosition::CAsyncTestMmfAclntAudioRepeatPlayGetPosition( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + + } + +void CAsyncTestMmfAclntAudioRepeatPlayGetPosition::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Repeat/Play/GetPosition")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call GetPosition (during Playback of Second repeat) for every 2 sec + iTestState = EStateGetPosition; + } + break; + } + case EStateGetPosition: + { + INFO_PRINTF1( _L("GetPosition CMdaAudioPlayerUtility")); + TInt err = iPlayer->GetPosition(iPosition); + if(err == KErrNone && iPosition <= iDuration * (iNumOfRepeatsSet+1) ) + { + INFO_PRINTF2(_L("GetPosition = %d"),I64INT(iPosition.Int64())); + INFO_PRINTF2(_L("TotalClip Duration Including Repeats = %d"),iDuration * (iNumOfRepeatsSet+1)); + + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call GetPosition (during Playback of Second repeat) for every 2 sec + iTestState = EStateGetPosition; + + break; + } + else + { + StopTest(err, EFail); + break; + } + } + case EStateStopTest: + { + StopTest(); // success + break; + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + +CAsyncTestMmfAclntDRMRepeatPlay* CAsyncTestMmfAclntDRMRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TDesC& aUniqueId, const TInt aRepeatCount) + { + return new (ELeave) CAsyncTestMmfAclntDRMRepeatPlay( aTestName, aSectName, aKeyName, aUniqueId, aRepeatCount); + } + +CAsyncTestMmfAclntDRMRepeatPlay::CAsyncTestMmfAclntDRMRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TDesC& aUniqueId,const TInt aRepeatCount) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + iUniqueId = aUniqueId; + iNumOfRepeatsSet = aRepeatCount; + } + +void CAsyncTestMmfAclntDRMRepeatPlay::KickoffTestL() + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Player Util")); + TPtrC filename1; + TInt repeatCount; + TInt silence; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + ERR_PRINTF1(_L("GetStringFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("numOfRepeat"), repeatCount)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + if(!GetIntFromConfig(_L("SectionSilence"), _L("silence"), silence)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + iSilence = silence; + iNumOfRepeatsSet = repeatCount; + + GetDriveName(iFileName); + iFileName.Append(filename1); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &iFileName); + iTrigger = CFsmTrigger::NewL(*this); + + INFO_PRINTF1( _L("TestPlayerUtils : DRM Audio Repeat/Play")); + iPlayer = CMdaAudioPlayerUtility::NewL(*this); + iPlayer->OpenFileL(TMMFileSource(iFileName, iUniqueId, ContentAccess::EPlay)); + iPlayerState = EOpening; + } + +void CAsyncTestMmfAclntDRMRepeatPlay::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iClipDuration = aDuration; + if (aError == KErrNone) + { + INFO_PRINTF2(_L("*MapcInitComplete* Error: %d."), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateStopTest; + } + else if(aError == KErrCANoPermission) + { + INFO_PRINTF2(_L("*MapcInitComplete* Error: %d Rights expired"), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateStopTest; + } + else + { + StopTest(aError, EFail); + } + } +void CAsyncTestMmfAclntDRMRepeatPlay::MapcPlayComplete(TInt aError) + { + if(aError == KErrNone ) + { + INFO_PRINTF2(_L("*MapcPlayComplete* Error: %d"), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateStopTest; + } + else if(aError == KErrCANoPermission) + { + INFO_PRINTF2(_L("*MapcPlayComplete* Error: %d Rights expired"), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateStopTest; + } + else + { + StopTest(aError, EFail); + } + } +void CAsyncTestMmfAclntDRMRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + } + break; + } + case EStateStopTest: + { + StopTest(); // success + break; + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + + + + +//============================================================================================================= +//RAsync Negative tests +//============================================================================================================== + + + +CAsyncTestMmfAclntAudioNegativeRepeatPlay* CAsyncTestMmfAclntAudioNegativeRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioNegativeRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioNegativeRepeatPlay::CAsyncTestMmfAclntAudioNegativeRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioNegativeRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio NegativeRepeat/Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),KNegativeRepeat); + iPlayer->SetRepeats(KNegativeRepeat,iSilence); + + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration); + if(TimeComparison(iActualDuration, iDuration, + KExpectedDeviation)) + { + StopTest(); // success + break; + } + else + { + STOP_TEST_GEN_ERROR; + break; + } + } + else + { + StopTest(); + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + + +CAsyncTestMmfAclntAudioPlayNegativeRepeat* CAsyncTestMmfAclntAudioPlayNegativeRepeat::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioPlayNegativeRepeat( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioPlayNegativeRepeat::CAsyncTestMmfAclntAudioPlayNegativeRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioPlayNegativeRepeat::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Play/NegativeRepeat")); + iDuration = I64INT(iPlayer->Duration().Int64()); + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),KNegativeRepeat); + iPlayer->SetRepeats(KNegativeRepeat,iSilence); + + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Expected Duration = %d "),iDuration); + if(TimeComparison(iActualDuration, iDuration, + KExpectedDeviation)) + { + StopTest(); // success + break; + } + else + { + STOP_TEST_GEN_ERROR; + break; + } + } + else + { + StopTest(); + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +//============================================================================================================ + +CAsyncTestMmfAclntRepeatMultipleFiles* CAsyncTestMmfAclntRepeatMultipleFiles::NewL( const TDesC& aTestName, const TDesC& aSectName) + { + return new (ELeave) CAsyncTestMmfAclntRepeatMultipleFiles( aTestName, aSectName); + } + +CAsyncTestMmfAclntRepeatMultipleFiles::CAsyncTestMmfAclntRepeatMultipleFiles( const TDesC& aTestName, const TDesC& aSectName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, KNullDesC), iCount(0) + { + } +void CAsyncTestMmfAclntRepeatMultipleFiles::KickoffTestL() + { + INFO_PRINTF1( _L("TestPlayerUtils : Audio Player Util")); + TInt repeatCount; + + if(!GetIntFromConfig(_L("SectionRepeatCount"), _L("numOfRepeat"), repeatCount)) + { + ERR_PRINTF1(_L("GetIntFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + iTrigger = CFsmTrigger::NewL(*this); + iPlayer = CMdaAudioPlayerUtility::NewL(*this); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + } +void CAsyncTestMmfAclntRepeatMultipleFiles::FsmL() + { + switch (iTestState) + { + case EStateOpen: + { + INFO_PRINTF1( _L("TestPlayerUtils :Audio Repeat/Play for multiple files")); + TPtrC fileName; + iFileName = KTestParameters[iCount].iFilename; + if(!GetStringFromConfig(iSectName, iFileName, fileName)) + { + //return EInconclusive; + ERR_PRINTF1(_L("GetStringFromConfig Failed")); + StopTest(KErrGeneral, EInconclusive); + return; + } + + GetDriveName(iFileName); + iFileName.Append(fileName); + INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &iFileName); + iPlayer->OpenFileL(iFileName); + iPlayerState = EOpening; + break; + } + case EStateOpened: + { + iDuration = I64INT(iPlayer->Duration().Int64()); + iPlayer->SetRepeats(KTestParameters[iCount].iRepeatCount, TTimeIntervalMicroSeconds(KTestParameters[iCount].iSilence)); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStatePlay; + break; + } + case EStatePlay: + { + if(iPlayerState == EOpened) + { + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + iPlayer->Play(); + iPlayerState = EPlaying; + } + break; + } + case EStateStopTest: + { + if(iCount == KNoOfTestFiles-1) + { + StopTest(); // success + } + else + { + iCount++; + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(KOneSecond); // Call SetRepeat for this test case after two sec + iTestState = EStateOpen; + } + break; + } + default: + STOP_TEST_GEN_ERROR; + break; + } + } + +// PDEF131534 SPPR_PERF: Music player crashes when opening corrupted wav file. +// WAV file of 96000 Hz is not supported. +void CAsyncTestMmfAclntRepeatMultipleFiles::MapcInitComplete(TInt aError, + const TTimeIntervalMicroSeconds &aDuration) + { + iError = aError; + iClipDuration = aDuration; + if (aError != KErrNone) + { + TInt match = iFileName.Match(_L("*100khzSRate1KhzTone.wav")); + if (aError == KErrNotSupported && match != KErrNotFound) + { + INFO_PRINTF1( _L("WAV file of frequency more than 96 KHz is not supported.")); + INFO_PRINTF1( _L("*MapcInitComplete* Expected Error: KErrNotSupported(-5)")); + INFO_PRINTF2(_L("*MapcInitComplete* Actual Error: %d."), aError); + StopTest(aError, EPass); + } + else + { + ERR_PRINTF2(_L("*MapcInitComplete* Error: %d."), aError); + StopTest(aError, EFail); + } + } + else + { + INFO_PRINTF2(_L("*MapcInitComplete* Error: %d."), aError); + iTrigger->Cancel(); // ensure assert in StartTimer always succeeds + iTrigger->StartTimer(500000); + iTestState = EStateOpened; + iPlayerState = EOpened; + } + } +//============================================================================================================ + + +CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay* CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay::NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + { + return new (ELeave) CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay( aTestName, aSectName, aKeyName); + } + +CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay::CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName) + : CAsyncTestMmfAclntAudioPlayerUtil( aTestName, aSectName, aKeyName) + { + } + +void CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay::FsmL() + { + switch (iTestState) + { + case EStateOpened: + { + INFO_PRINTF1( _L("TestPlayerUtils : SetPlayWindow Repeat Play")); + iDuration = I64INT(iPlayer->Duration().Int64()); + + TInt64 temp1, temp2; + temp1 = iPlayer->Duration().Int64()/2; + temp2 = iPlayer->Duration().Int64(); + iWindowDuration = (I64INT(temp2) - I64INT(temp1)); + + TTimeIntervalMicroSeconds startTime(temp1); + TTimeIntervalMicroSeconds endTime(temp2); + + INFO_PRINTF4(_L("StartTime = %d EndTime = %d WindowDuration = %d"), + I64INT(startTime.Int64()), I64INT(endTime.Int64()), iWindowDuration); + + TInt windowSet = iPlayer->SetPlayWindow(startTime,endTime); + if (windowSet != KErrNone) + { + ERR_PRINTF2( _L("Unexpected error returned from SetPlayWindow - %d"),windowSet); + StopTest(windowSet, EFail); + break; + } + + INFO_PRINTF1( _L("SetRepeats CMdaAudioPlayerUtility")); + INFO_PRINTF2( _L("Repeats = %d\n"),iNumOfRepeatsSet); + iPlayer->SetRepeats(iNumOfRepeatsSet,iSilence); + + INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility")); + + if(iPlayerState == EOpened) + { + iPlayer->Play(); + iPlayerState = EPlaying; + iStart.HomeTime(); + } + break; + } + case EStateStopTest: + { + if(iDuration) + { + iStop.HomeTime(); + iActualDuration = I64INT(iStop.MicroSecondsFrom(iStart).Int64()); + INFO_PRINTF2( _L("Clip Duration = %d "),iDuration); + INFO_PRINTF2( _L("Actual Duration = %u "),iActualDuration); + INFO_PRINTF2( _L("Window Duration = %d "),iWindowDuration); + #ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND + if(TimeComparison(iActualDuration, iWindowDuration*(iNumOfRepeatsSet+1), + KExpectedDeviation)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #else + if(TimeComparison(iActualDuration, iWindowDuration*(iNumOfRepeatsSet+1), + KExpectedDeviation*iNumOfRepeatsSet)) + { + StopTest(); // success + } + else + { + STOP_TEST_GEN_ERROR; + } + #endif + break; + } + else + { + StopTest(); + break; + } + } + default: + STOP_TEST_GEN_ERROR; + break; + } + }