--- /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 <caf/caf.h>
+
+// 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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<TInt>(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<TUid> 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<KSizeBuf> 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<KSizeBuf> 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<KSizeBuf> 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;
+ }
+ }