diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/tsrc/mmfunittest/MidiClnt/TestStepMidiDRM.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/MidiClnt/TestStepMidiDRM.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,512 @@ +// Copyright (c) 2005-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: +// + +#include + +#include "TSU_MMFMIDICLNT.h" +#include "TS_MMFMIDICLNTsuite.h" + +#include "TestMidiClientUtility.h" + +_LIT(KDrmSectName, "SectionDRM"); +_LIT(KDrmFileKey, "MidiDrmContent"); + +const TInt K1Second =1000000; +const TInt K5Seconds = 5 * K1Second; +const TInt K30Seconds =30 * K1Second; + +class CCallbackTimer : public CTimer + { +public: + static CCallbackTimer* NewL(); + ~CCallbackTimer(); + void SetCb(TCallBack aCallback) + { + iCallback = aCallback; + } + void After(TTimeIntervalMicroSeconds32 aCancelDelay) + { + CTimer::After(aCancelDelay); + } + void After(TTimeIntervalMicroSeconds32 aCancelDelay, TCallBack aCallback); + +private: + CCallbackTimer(); + // from CActive + void RunL(); + +private: + TCallBack iCallback; + }; + +CCallbackTimer* CCallbackTimer::NewL() + { + CCallbackTimer* self=new (ELeave) CCallbackTimer(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CCallbackTimer::CCallbackTimer():CTimer(EPriorityHigh) + { + CActiveScheduler::Add(this); + } + +CCallbackTimer::~CCallbackTimer() + { + Cancel(); + } + + +void CCallbackTimer::After(TTimeIntervalMicroSeconds32 aCancelDelay, TCallBack aCallback) + { + iCallback = aCallback; + CTimer::After(aCancelDelay); + } + +/** +* +* RunL +* +**/ +void CCallbackTimer::RunL() + { + iCallback.CallBack(); + } + + + +CTestStepDrm::CTestStepDrm(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams): + CTestMmfMidiClntStep(aTestName, aTestType), + iDrmParams(aDrmParams) + { + } + +TVerdict CTestStepDrm::DoTestStepPreambleL() + { + if (EPass==CTestMmfMidiClntStep::DoTestStepPreambleL()) + { + iTimer = CCallbackTimer::NewL(); + iTimer->SetCb(TCallBack(TimerGate, this)); + User::LeaveIfError( iFs.Connect() ); + return EPass; + } + return EFail; + } + +TVerdict CTestStepDrm::DoTestStepPostambleL() + { + delete iTimer; + iTimer = NULL; + + iFile.Close(); + iFs.Close(); + return CTestMmfMidiClntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepDrm::DoTestStepL() + { + if (iDrmParams.iTestMode != TDrmTestParams::EAlloc) + { + return CTestMmfMidiClntStep::DoTestStepL(); + } + TVerdict result=EPass; + TInt failCount = 1; + TBool completed = EFalse; + CMidiClientUtility* midiClnt = NULL; + TInt err; + while(!completed) + { + iError = KErrNone; + __UHEAP_SETFAIL(RHeap::EFailNext ,failCount); + __MM_HEAP_MARK; + + TRAP( err, + midiClnt = CMidiClientUtility::NewL(*this); + result=DoTestL(midiClnt); + ); + iTimer->Cancel(); + + completed = EFalse; + if (err == KErrNone) + { + TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test + if (testAlloc==NULL) + { + completed = ETrue; + } + else + { + completed = ETrue; + User::Free(testAlloc); + } + } + else if (err != KErrNoMemory) // bad error code + { + completed = ETrue; + result = EFail; + } + else + { + ++failCount; + } + + delete midiClnt; + midiClnt = NULL; + + __UHEAP_RESET; + __MM_HEAP_MARKEND; + } + return result; + } + +/*static*/ +TInt CTestStepDrm::TimerGate(TAny* aPtr) + { + reinterpret_cast(aPtr)->OnTimer(); + return KErrNone; + } + +void CTestStepDrm::OnTimer() + { + iTimer->Cancel(); + CActiveScheduler::Stop(); + iError = KErrTimedOut; + } + +TVerdict CTestStepDrm::OpenFileL(CMidiClientUtility* aMidi) + { + TPtrC fileName; + if (iDrmParams.iFileNameKey==NULL) + { + if(!GetStringFromConfig(KDrmSectName,KDrmFileKey,fileName)) + { + return EInconclusive; + } + } + else + { + if(!GetStringFromConfig(KDrmSectName,TPtrC(iDrmParams.iFileNameKey), fileName)) + { + return EInconclusive; + } + } + if (iDrmParams.iSourceType==TDrmTestParams::EFileName) + { + TPtrC uniqueId(ContentAccess::KDefaultContentObject); + if (iDrmParams.iUniqueId) + { + uniqueId.Set(TPtrC(iDrmParams.iUniqueId)); + } + if (iDrmParams.iUniqueId==NULL && iDrmParams.iIntent==TDrmTestParams::KNoIntent) + { + aMidi->OpenFile(TMMFileSource(fileName)); + } + else if (iDrmParams.iIntent==TDrmTestParams::KNoIntent) + { + aMidi->OpenFile(TMMFileSource(fileName, uniqueId)); + } + else + { + aMidi->OpenFile(TMMFileSource(fileName, uniqueId, iDrmParams.iIntent)); + } + } + else + { + iFile.Close(); + User::LeaveIfError( iFs.ShareProtected() ); + User::LeaveIfError( iFile.Open(iFs, fileName, EFileRead | EFileShareExclusive) ); + + TPtrC uniqueId(ContentAccess::KDefaultContentObject); + if (iDrmParams.iUniqueId) + { + uniqueId.Set(TPtrC(iDrmParams.iUniqueId)); + } + if (iDrmParams.iUniqueId==NULL && iDrmParams.iIntent==TDrmTestParams::KNoIntent) + { + aMidi->OpenFile(TMMFileHandleSource(iFile)); + } + else if (iDrmParams.iIntent==TDrmTestParams::KNoIntent) + { + aMidi->OpenFile(TMMFileHandleSource(iFile, uniqueId)); + } + else + { + aMidi->OpenFile(TMMFileHandleSource(iFile, uniqueId, iDrmParams.iIntent)); + } + } + + return EPass; + } + + +/*static*/ +CTestDrmNegative* CTestDrmNegative::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams) + { + return new (ELeave) CTestDrmNegative(aTestName, aTestType, aDrmParams); + } + +CTestDrmNegative::CTestDrmNegative(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams): + CTestStepDrm(aTestName, aTestType, aDrmParams) + { + } + +void CTestDrmNegative::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState /*aNewState*/, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + +TVerdict CTestDrmNegative::DoTestL(CMidiClientUtility* aMidi) + { + iTimer->After( TTimeIntervalMicroSeconds32(K5Seconds) ); + TVerdict result=OpenFileL(aMidi); + if (result!=EPass) + { + iTimer->Cancel(); + return result; + } + CActiveScheduler::Start(); + + if (iError!=iDrmParams.iExpectedError) + { + result=EFail; + ERR_PRINTF3(_L("Open() gave error %d (expected %d)"),iError, iDrmParams.iExpectedError); + } + iTimer->Cancel(); + return result; + } + + +/*static*/ +CTestDrmPlay* CTestDrmPlay::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams) + { + return new (ELeave) CTestDrmPlay(aTestName, aTestType, aDrmParams); + } + +CTestDrmPlay::CTestDrmPlay(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams): + CTestStepDrm(aTestName, aTestType, aDrmParams) + { + } + +void CTestDrmPlay::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState aNewState, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError) + { + iError = aError; + iLatestState= aNewState; + CActiveScheduler::Stop(); + } + +TVerdict CTestDrmPlay::PlayL(CMidiClientUtility* aMidi, TTimeIntervalMicroSeconds32 aStopAfter) + { + iTimer->Cancel(); + iTimer->After(aStopAfter); + + TVerdict result=OpenFileL(aMidi); + if (result!=EPass) + { + iTimer->Cancel(); + return result; + } + CActiveScheduler::Start(); + User::LeaveIfError(iError); + + aMidi->Play(); + CActiveScheduler::Start(); + User::LeaveIfError(iError); + if (iLatestState != EMidiStateOpenPlaying) + { + iTimer->Cancel(); + ERR_PRINTF3(_L("Play() got state %d (expected %d)"),iLatestState, EMidiStateOpenPlaying); + return EFail; + } + + CActiveScheduler::Start(); + + iTimer->Cancel(); + if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc) + { + User::Leave(iError); + } + + return result; + } + +TVerdict CTestDrmPlay::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict res=EPass; + TInt i=iDrmParams.iNumPlayLoops > 0 ? iDrmParams.iNumPlayLoops : 1; + for (; i && res==EPass && iError==KErrNone; --i) + { + TRAP( iError, + res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K30Seconds)); + ); + } + if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc) + { + User::Leave(iError); + } + if (res==EPass) + { + res=(i==0 && iDrmParams.iExpectedError==iError)? EPass : EFail; + } + + if (iError!=iDrmParams.iExpectedError) + { + ERR_PRINTF4(_L("Play() gave error %d (expected %d) loops left=%d"),iError, iDrmParams.iExpectedError, i); + } + return res; + } + +/* +***** Play() -> Stop() +*/ +CTestDrmPlayStop* CTestDrmPlayStop::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams) + { + return new (ELeave) CTestDrmPlayStop(aTestName, aTestType, aDrmParams); + } + + +CTestDrmPlayStop::CTestDrmPlayStop(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams): + CTestDrmPlay(aTestName, aTestType, aDrmParams) + { + } + +void CTestDrmPlayStop::OnTimer() + { + if (iLatestState != EMidiStateOpenPlaying || iStopping) + { + iError = KErrGeneral; + CActiveScheduler::Stop(); + ERR_PRINTF3(_L("CTestDrmPlayStop::OnTimer() got err %d stopping %d"),iError, iStopping); + } + else + { + iMidi->Stop(TTimeIntervalMicroSeconds(100000)); + iStopping=ETrue; + iTimer->After(K5Seconds); + } + } + +TVerdict CTestDrmPlayStop::DoTestL(CMidiClientUtility* aMidi) + { + iMidi = aMidi; + TVerdict res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K5Seconds)); + iTimer->Cancel(); + if (res!=EPass) + { + return res; + } + return iError==iDrmParams.iExpectedError ? EPass : EFail; + } + +/* +***** Play() -> Stop() +*/ + +/*static*/ +CTestDrmPlayWithUI* CTestDrmPlayWithUI::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams) + { + return new (ELeave) CTestDrmPlayWithUI(aTestName, aTestType, aDrmParams); + } + +CTestDrmPlayWithUI::CTestDrmPlayWithUI(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams): + CTestStepDrm(aTestName, aTestType, aDrmParams) + { + } + +void CTestDrmPlayWithUI::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState aNewState, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError) + { + iError = aError; + iLatestState= aNewState; + CActiveScheduler::Stop(); + } + +TVerdict CTestDrmPlayWithUI::PlayL(CMidiClientUtility* aMidi, TTimeIntervalMicroSeconds32 aStopAfter) + { + iTimer->Cancel(); + iTimer->After(aStopAfter); + + TVerdict result=OpenFileL(aMidi); + if (result!=EPass) + { + iTimer->Cancel(); + return result; + } + CActiveScheduler::Start(); + User::LeaveIfError(iError); + + MMMFDRMCustomCommand* cmd=aMidi->GetDRMCustomCommand(); + if (cmd==NULL) + { + ERR_PRINTF1(_L("GetDRMCustomCommand() returned NULL")); + return EFail; + } + iError=cmd->SetAgentProperty(ContentAccess::EAgentPropertyAgentUI, ETrue); + // The test agent should return KErrCANotSupported... + if (iError != KErrCANotSupported) + { + ERR_PRINTF2(_L("SetAgentProperty() Error=%d"),iError); + return EFail; + } + else + { + // ..it has, so flag that there's no error! + iError = KErrNone; + } + User::LeaveIfError(iError); + + aMidi->Play(); + CActiveScheduler::Start(); + User::LeaveIfError(iError); + + if (iLatestState != EMidiStateOpenPlaying) + { + iTimer->Cancel(); + ERR_PRINTF3(_L("Play() got state %d (expected %d)"),iLatestState, EMidiStateOpenPlaying); + return EFail; + } + + CActiveScheduler::Start(); + + iTimer->Cancel(); + if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc) + { + User::Leave(iError); + } + + return EPass; + } + +TVerdict CTestDrmPlayWithUI::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict res=EPass; + TInt i=iDrmParams.iNumPlayLoops > 0 ? iDrmParams.iNumPlayLoops : 1; + for (; i && res==EPass; --i) + { + res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K30Seconds)); + } + if (res==EFail) + { + return res; + } + if (iError!=iDrmParams.iExpectedError) + { + res=EFail; + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, iDrmParams.iExpectedError); + } + return res; + } +