--- /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 <testframework.h>
+
+#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<CTestStepDrm*>(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;
+	}
+