--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepPlayerSharedHeap.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,597 @@
+// 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:
+// These test steps create audio player utilities whose
+// controllers share a single heap.
+//
+//
+
+// EPOC includes
+#include <e32base.h>
+#include <e32test.h>
+#include <e32keys.h>
+#include <c32comm.h>
+#include <f32file.h>
+#include <etel.h>
+#include <etelmm.h>
+#include <testframework.h>
+
+#include <mdaaudiosampleplayer.h>
+
+// Test system includes
+#include <testframework.h>
+
+// Specific includes for this test suite
+#include "TestStepUnitMMFAudClient.h"
+
+// Specific includes for these test steps
+#include "TestStepPlayerSharedHeap.h"
+
+#include "mmfclientaudioplayer.h"
+
+// For custom controller
+#include "../../ctlfrm/TS_CMMFTestController/CmmfTestControllerUIDs.hrh"
+#include "../../ctlfrm/TS_Codes.h"
+
+// --------------------------------------------
+
+const TInt KMaxPlayers = 24;
+// would definitely exceed the chunk limit if there players were
+// using separate heaps (which they shouldn't in this test)
+
+
+const TInt KNoSharedPlayer = 2;
+// which of the created players should be given its own heap on mixed style tests
+// This must always be true: KNoSharedPlayer < KMaxPlayers
+
+
+const TInt KRepeatAmount = 16;
+// how often CTestStepPlayerSharedHeapRepeatMultiFilePlayer should create and delete players
+
+
+const TUid KTstControllerUid = {KMmfTestControllerUid}; //(0x101F88D8)
+// custom controller ID
+
+// --------------------------------------------
+
+
+/**
+ *
+ * Static constructor for CTestStepPlayerSharedHeapMultiFilePlayer.
+ *
+ *
+ * @return "CTestStepPlayerSharedHeapMultiFilePlayer*"
+ * The constructed CTestStepPlayerSharedHeapMultiFilePlayer
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapMultiFilePlayer* CTestStepPlayerSharedHeapMultiFilePlayer::NewL(const TDesC& aName, TBool aMixHeapStyle )
+ {
+ CTestStepPlayerSharedHeapMultiFilePlayer* self = new(ELeave) CTestStepPlayerSharedHeapMultiFilePlayer( aName, aMixHeapStyle );
+ return self;
+ }
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapMultiFilePlayer::CTestStepPlayerSharedHeapMultiFilePlayer(const TDesC& aName, TBool aMixHeapStyle )
+ : iMixHeapStyle( aMixHeapStyle )
+ {
+ // store the name of this test case
+ // this is the name that is used by the script file
+ iTestStepName = aName;
+
+ iHeapSize = 128 * 1024;
+ }
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapMultiFilePlayer::~CTestStepPlayerSharedHeapMultiFilePlayer()
+ {
+ }
+
+/**
+ * Implementation of the MMdaAudioPlayerCallback interface functions
+ **/
+void CTestStepPlayerSharedHeapMultiFilePlayer::MapcInitComplete(TInt aError,
+ const TTimeIntervalMicroSeconds &/*aDuration*/)
+ {
+ iError = aError;
+
+ if( aError )
+ {
+ INFO_PRINTF2(_L(" Callback error (%d) while opening player."), aError);
+ }
+ /*else
+ {
+ INFO_PRINTF1(_L(" Player opened successfully."));
+ }*/
+ CActiveScheduler::Stop();
+ }
+
+void CTestStepPlayerSharedHeapMultiFilePlayer::MapcPlayComplete(TInt aError)
+ {
+ iError = aError;
+ CActiveScheduler::Stop();
+ }
+
+/**
+ *
+ * Test step Preamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepPreambleL(void)
+ {
+ enum TVerdict verdict;
+ // this installs the scheduler
+ verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
+
+ // Printing to the console and log file
+ INFO_PRINTF1( iTestStepName );
+
+ iError = KErrNone; //KErrTimedOut;
+
+ if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName1"), iFileName))
+ {
+ return EInconclusive;
+ }
+
+
+ return verdict;
+ }
+
+/**
+ *
+ * Test step Postamble.
+ *
+ * @xxxx
+ *
+ */
+enum TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepPostambleL(void)
+ {
+ // close array
+ iPlayers.Close();
+
+ INFO_PRINTF1(_L("finished with this test step"));
+
+ //[ Destroy the scheduler ]
+ return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
+ }
+
+/**
+ *
+ * The commands to be included in the TRAP command
+ *
+ * @xxxx
+ *
+ */
+CMdaAudioPlayerUtility* CTestStepPlayerSharedHeapMultiFilePlayer::CreateAndOpenPlayerL( TInt aIteration )
+ {
+ CMdaAudioPlayerUtility* player = NULL;
+
+ TRAPD( err, player = CMdaAudioPlayerUtility::NewL(*this) );
+ User::LeaveIfError( err );
+ CleanupStack::PushL(player);
+
+ if( ! (iMixHeapStyle && (aIteration == KNoSharedPlayer)) )
+ {
+ INFO_PRINTF2(_L(" Player on iteration %2d is using a shared heap."), aIteration );
+ player->UseSharedHeap(); // ensure that underlying controller uses a shared heap
+ }
+ else
+ {
+ INFO_PRINTF2(_L(" Player on iteration %2d has its own heap."), aIteration );
+ }
+
+ player->OpenFileL( iFileName ); // this creates a new controller
+
+ CActiveScheduler::Start(); // wait for open to complete
+
+ User::LeaveIfError( iError ); // if had error return from callback
+
+ CleanupStack::Pop(player);
+ return player;
+ }
+
+/**
+ *
+ * Get's the Audio Player State
+ *
+ * @xxxx
+ *
+ */
+
+TInt CTestStepPlayerSharedHeapMultiFilePlayer::GetAudPlayerState(CMdaAudioPlayerUtility* aPlayer, TInt& aState)
+ {
+ if (aPlayer == NULL)
+ return KErrNotReady;
+ aState = this->iState;
+ return KErrNone;
+ }
+
+/**
+ *
+ * Get's the Audio Player Source Handle
+ *
+ * @xxxx
+ *
+ */
+TInt CTestStepPlayerSharedHeapMultiFilePlayer::GetAudPlayerSourceHandle(CMdaAudioPlayerUtility* aPlayer,
+ TMMFMessageDestination* /*aSrcHandle*/)
+ {
+ if (aPlayer == NULL)
+ return KErrNotReady;
+ return KErrNone;
+ }
+
+
+
+/**
+ *
+ * Creates KMaxPlayers players, performs the desired test on one of them
+ * and then closes them all and cleans up.
+ * If problems are encountered the returned result will reflect this.
+ *
+ * @return "TVerdict"
+ * The result of the tests
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestL( TTestType aTestType )
+ {
+ iTestStepResult = EPass;
+ TInt err = KErrNone;
+
+ __MM_HEAP_MARK;
+
+ TInt i=0;
+ for( ; i < KMaxPlayers; ++i )
+ {
+ iError = KErrNone;
+
+ CMdaAudioPlayerUtility* player = NULL;
+
+ TRAPD(err, player = CreateAndOpenPlayerL(i) );
+
+ if (err == KErrNone && iError == KErrNone)
+ {
+ // see if valid result and break if wrong - might be premature result
+ TInt err1 = KErrNone;
+ TInt err2 = KErrNone;
+ TInt state = 0;
+ TMMFMessageDestination* srcHandle = NULL;
+ err1 = GetAudPlayerState(player, state);
+ err2 = GetAudPlayerSourceHandle(player, srcHandle);
+ if ( err1 != KErrNone ||
+ err2 != KErrNone ||
+ &srcHandle == NULL ||
+ state != CTestStepPlayerSharedHeapMultiFilePlayer::EStopped ||
+ player->Duration() == TTimeIntervalMicroSeconds(0) || // we know the duration of the file is more than 0
+ iError != KErrNone)
+ {
+ // dodgy player
+
+ INFO_PRINTF2(_L(" Dodgy player on iteration %2d"), i);
+ iTestStepResult = EFail;
+
+ delete player;
+ player = NULL;
+ break;
+ }
+ else
+ {
+ // no errors
+ // append player to array
+ if( (err = iPlayers.Append( player )) != KErrNone )
+ {
+ INFO_PRINTF2(_L("Fail to append player on iteration %2d"), i);
+ // this doesn't indicate a failure in what we're testing here
+ iTestStepResult = EInconclusive;
+
+ delete player;
+ player = NULL;
+ break;
+ }
+ }
+ }
+ else
+ {
+ INFO_PRINTF4(_L("Fail to open player on iteration %2d - %d %d"), i, err, iError);
+ break;
+ }
+ }
+
+ // check outcome of making players
+ if ( err || iError )
+ {
+ if ((err && err != KErrNoMemory) || (err == KErrNone && iError != KErrNoMemory))
+ {
+ // a genuine error
+
+ if( err )
+ {
+ INFO_PRINTF3(_L("Error %d occured while trying to create player #%d"), err, i );
+ }
+ else
+ {
+ INFO_PRINTF3(_L("Error %d occured while opening player #%d"), iError, i );
+ }
+
+ iTestStepResult = EFail;
+ }
+ else
+ {
+ // we ran out of memory
+ INFO_PRINTF2(_L("Teststep ran out of memory while creating player #%d"), i );
+ iTestStepResult = EFail;
+ }
+ }
+ // else no errors
+
+
+ // perform test on 1st player (unless there were errors above)
+ if( (iTestStepResult == EPass) && (iPlayers.Count() > 0 ) )
+ {
+ switch( aTestType )
+ {
+ case EPlay:
+ {
+ (iPlayers[0])->Play();
+ CActiveScheduler::Start();
+
+ if( iError )
+ {
+ // playback died
+ INFO_PRINTF2(_L("Error %d occured while playing"), iError );
+ iTestStepResult = EFail;
+ }
+
+ break;
+ }
+
+
+ case EPanic:
+ {
+ // panic player
+
+ // load a custom controller (using the share heap)
+ // that can be panicked and see if we recover OK
+ TMMFPrioritySettings settings;
+ TInt error = KErrNone;
+ RMMFController controller;
+
+ settings.iPriority = 1;
+ settings.iPref = EMdaPriorityPreferenceTime;
+ settings.iState = EMMFStateIdle;
+
+ error = controller.Open(KTstControllerUid, settings, ETrue); // use shared heap
+ INFO_PRINTF2(_L("Custom controller Open: %d"), error);
+
+ if( ! error )
+ {
+ // panic the controller
+ // this command will complete immediately and
+ // then panic
+ TUid uid;
+ uid = TUid::Uid(0x101f72B4);
+ TMMFMessageDestinationPckg destPckg(uid);
+ //TRequestStatus status = KRequestPending;
+ controller.CustomCommandSync(destPckg,
+ EMMFTestCustomCommandPanic,
+ KNullDesC8,
+ KNullDesC8);
+
+ // need to allow some time to make
+ // sure the thread has actually been panicked when we close it
+ User::After( TTimeIntervalMicroSeconds32(5000000) ); // 5 seconds
+ }
+
+ // controller should have panicked by now
+ controller.Close();
+
+ break;
+ }
+
+
+ // default: // do nothing
+ }
+ }
+
+ // cleanup
+ for( i = 0; i < iPlayers.Count(); ++i )
+ {
+ delete iPlayers[i];
+
+ iPlayers[i] = NULL;
+ }
+ iPlayers.Reset();
+
+ __MM_HEAP_MARKEND;
+
+ // test steps return a result
+ return iTestStepResult;
+ }
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return "TVerdict"
+ * The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepL()
+ {
+ INFO_PRINTF1(_L("This is a test that several player utilities using a shared heap can be created."));
+
+ return DoTestL( EPlay );
+ }
+
+
+//===========================================================================================
+
+/**
+ *
+ * Static constructor for CTestStepPlayerSharedHeapRepeatMultiFilePlayer.
+ *
+ *
+ * @return "CTestStepPlayerSharedHeapRepeatMultiFilePlayer*"
+ * The constructed CTestStepPlayerSharedHeapRepeatMultiFilePlayer
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapRepeatMultiFilePlayer* CTestStepPlayerSharedHeapRepeatMultiFilePlayer::NewL(const TDesC& aName, TBool aMixHeapStyle )
+ {
+ CTestStepPlayerSharedHeapRepeatMultiFilePlayer* self = new(ELeave) CTestStepPlayerSharedHeapRepeatMultiFilePlayer( aName, aMixHeapStyle );
+ return self;
+ }
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapRepeatMultiFilePlayer::CTestStepPlayerSharedHeapRepeatMultiFilePlayer(const TDesC& aName, TBool aMixHeapStyle )
+ : CTestStepPlayerSharedHeapMultiFilePlayer( aName, aMixHeapStyle )
+ {
+ }
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapRepeatMultiFilePlayer::~CTestStepPlayerSharedHeapRepeatMultiFilePlayer()
+ {
+ }
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return "TVerdict"
+ * The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepPlayerSharedHeapRepeatMultiFilePlayer::DoTestStepL()
+ {
+ INFO_PRINTF1(_L("This is a test that several player utilities using a shared heap can be created."));
+
+ TVerdict result = EPass;
+
+ __MM_HEAP_MARK;
+
+ for(TInt i=0; i < KRepeatAmount; ++i)
+ {
+ INFO_PRINTF2(_L("Create and delete iteration %d."), i );
+ result = DoTestL( EPlay );
+
+ if( result != EPass )
+ {
+ INFO_PRINTF2(_L("Iteration %d failed. Stopping."), i );
+ break;
+ }
+ }
+
+ __MM_HEAP_MARKEND;
+
+ return result;
+ }
+
+// =============================================================
+
+/**
+ *
+ * Static constructor for CTestStepPlayerSharedHeapPanicMultiFilePlayer.
+ *
+ *
+ * @return "CTestStepPlayerSharedHeapPanicMultiFilePlayer*"
+ * The constructed CTestStepPlayerSharedHeapPanicMultiFilePlayer
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapPanicMultiFilePlayer* CTestStepPlayerSharedHeapPanicMultiFilePlayer::NewL(const TDesC& aName, TBool aMixHeapStyle )
+ {
+ CTestStepPlayerSharedHeapPanicMultiFilePlayer* self = new(ELeave) CTestStepPlayerSharedHeapPanicMultiFilePlayer( aName, aMixHeapStyle );
+ return self;
+ }
+
+/**
+ *
+ * Test step constructor.
+ * Each test step initialises its own name.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapPanicMultiFilePlayer::CTestStepPlayerSharedHeapPanicMultiFilePlayer(const TDesC& aName, TBool aMixHeapStyle )
+ : CTestStepPlayerSharedHeapMultiFilePlayer( aName, aMixHeapStyle )
+ {
+ }
+
+/**
+ *
+ * Test step destructor.
+ *
+ * @xxxx
+ *
+ */
+CTestStepPlayerSharedHeapPanicMultiFilePlayer::~CTestStepPlayerSharedHeapPanicMultiFilePlayer()
+ {
+ }
+
+/**
+ *
+ * Do the test step.
+ * Each test step must supply an implementation for DoTestStepL.
+ *
+ * @return "TVerdict"
+ * The result of the test step
+ *
+ * @xxxx
+ *
+ */
+TVerdict CTestStepPlayerSharedHeapPanicMultiFilePlayer::DoTestStepL()
+ {
+ INFO_PRINTF1(_L("This is a test that shared heap layers can recover from a panic."));
+
+ return DoTestL( EPanic );
+ }
+