// 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:

//

#ifndef __TSU_MMF_SRSSNK_H__

#define __TSU_MMF_SRSSNK_H__

#include <e32math.h>

#include <testframework.h>

#include <mmf/server/mmfdatapath.h>

#include "CmmfTestControllerUIDs.hrh"

#include <mmf/plugin/mmfformatimplementationuids.hrh>

#include "TS_Codes.h"

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfcontroller.h>

#include <mmf/server/mmfdes.h>

#include <mmf/server/mmffile.h>

#include <mmf/server/mmfurl.h>

#include <mmf/server/mmfaudioinput.h>

#include <mmf/server/mmfaudiooutput.h>

#include "../../../../../mmplugins/mmfwplugins/src/Plugin/Format/MmfWAVFormat/mmfwavformat.h"

const TInt KTestBufferSize = 1032; // 1024 + 8

const TInt KTestDataSize = 51200; // 50K

const TInt KTestOverDataSize = KTestDataSize + 20;

const TInt KTestReadSize = KTestBufferSize/2;

const TInt KTestOverReadSize = KTestBufferSize + 10;

const TInt KTestWriteSize = KTestBufferSize/2;

const TInt KTestOverWriteSize = KTestBufferSize + 10;

class CTestSuite;

class CTestSuite_MMF_SRSSNK;

enum TSourceType

	{

	ESourceTypeDes,

	ESourceTypeFile,

	ESourceTypeFileHandle,

	ESourceTypeAudio

	};

enum TSinkType

	{

	ESinkTypeFile,

	ESinkTypeFileHandle

	};

class TThreadData

	{

public:

	TThreadData()

	: iFileSize(-1), iErr(KErrNone)

	{ }

public:

	CMMFFile* iFilePtr;

	MAsyncEventHandler *iEventHandler;

	TInt iFileSize;

	TInt iErr;

	};

const TUid KTestDummyUid = { -1 };

class CMMFTestBuffer : public CMMFBuffer

	{

public:

	CMMFTestBuffer()

	: CMMFBuffer(KTestDummyUid)

	{ }

	TUint BufferSize() const

	{ return 0; }

	};

MDataSink* CreateFileSinkL(TSinkType aSinkType, RFs& aFs, const TDesC& aFileName); 

MDataSource* CreateFileSourceL(TSourceType aSourceType, RFs& aFs, const TDesC& aFileName); 

MDataSource* CreateFileHandleSourceL(RFs& aFs, const TDesC& aFileName);

class CMMFDummySource : public CBase, public MDataSource, public MAsyncEventHandler

	{

public:

	CMMFDummySource();

	void SetExpectedEmptyCount(TInt aExpectedEmptyCount)

	{ iExpectedEmptyCount = aExpectedEmptyCount; }

	TBool BufferEmptiedOk()

		{

		TBool bufferEmptiedOk = iBufferEmptiedOk;

		if (bufferEmptiedOk)

			ResetBufferEmptiedOk();

		return bufferEmptiedOk;

		}

	void ResetBufferEmptiedOk()

	{ iBufferEmptiedOk = EFalse ; iEmptyCount = 0 ; iErrorCount = 0 ; iExpectedEmptyCount = 1; } 

	// From MDataSource

	TFourCC SourceDataTypeCode(TMediaId aMediaId);

	void FillBufferL(CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId aMediaId);

	void BufferEmptiedL(CMMFBuffer* aBuffer);

	TBool CanCreateSourceBuffer();

	CMMFBuffer* CreateSourceBufferL(TMediaId aMediaId, TBool &aReference);

	// MAsyncEventHandler

	TInt SendEventToClient(const TMMFEvent& aEvent);

	TInt Error()

	{ ResetBufferEmptiedOk() ; return iError; }

	TInt ErrorCount()

	{ return iErrorCount; }

	void SetFillBuffer()

	{ iFillBuffer = ETrue; }

	void SetActiveScheduler()

	{ iActiveScheduler = CActiveScheduler::Current(); }

	void ClearActiveScheduler()

	{ iActiveScheduler = NULL; }

	CMMFBuffer* MmfBuffer()

	{ return iBuffer; }

protected:

	void ConstructSourceL(const TDesC8& aInitData);

private:

	TFourCC iSourceDataTypeCode;

	TBool iBufferEmptiedOk;

	TInt iEmptyCount;

	TInt iExpectedEmptyCount;

	CActiveScheduler *iActiveScheduler;

	TInt iError;

	TInt iErrorCount;

	TBool iFillBuffer;

	CMMFBuffer* iBuffer;	// buffer returned in BufferEmptiedL callback

	};

class CMMFDummySink : public CBase, public MDataSink, public MAsyncEventHandler

	{

public:

	CMMFDummySink();

	void SetExpectedFillCount(TInt aExpectedFillCount)

	{ iExpectedFillCount = aExpectedFillCount; }

	TBool BufferFilledOk()

		{

		TBool bufferFilledOk = iBufferFilledOk;

		if (bufferFilledOk)

			ResetBufferFilledOk();

		return bufferFilledOk;

		}

	void ResetBufferFilledOk()

	{ iBufferFilledOk = EFalse ; iFillCount = 0 ; iErrorCount = 0 ; iExpectedFillCount = 1; }

	void BufferFilledError();

	// From MDataSink

	TFourCC SinkDataTypeCode(TMediaId aMediaId);

	void EmptyBufferL(CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId aMediaId);

	void BufferFilledL(CMMFBuffer* aBuffer);

	TBool CanCreateSinkBuffer();

	CMMFBuffer* CreateSinkBufferL(TMediaId aMediaId, TBool &aReference);

	// MAsyncEventHandler

	TInt SendEventToClient(const TMMFEvent& aEvent);

	TInt Error()

	{ ResetBufferFilledOk() ; return iError; }

	TInt ErrorCount()

	{ return iErrorCount; }

	CMMFBuffer* MmfBuffer()

	{ return iBuffer; }

protected:

	void ConstructSinkL(const TDesC8& aInitData);

private:

	TFourCC iSinkDataTypeCode;

	TBool iBufferFilledOk;

	TInt iFillCount;

	TInt iExpectedFillCount;

	CActiveScheduler *iActiveScheduler;

	TInt iError;

	TInt iErrorCount;

	CMMFBuffer* iBuffer;	// buffer returned in BufferFilledL callback

	};

class TTestStep

	{

public:

	TTestStep()

	: iSource(NULL), iSink(NULL)

	{ }

	TTestStep(MDataSource* aSource)

	: iSource(aSource), iSink(NULL)

	{ }

	TTestStep(MDataSink* aSink)

	: iSource(NULL), iSink(aSink)

	{ }

	TTestStep(MDataSource* aSource, MDataSink* aSink)

	: iSource(aSource), iSink(aSink)

	{ }

	virtual TVerdict DoTestStepL() = 0;

	virtual void DoTestPreambleL();

	virtual TVerdict DoTestPostambleL(TBool aCheck);

	virtual TVerdict DoNegativeTestPostambleL();

	virtual MDataSource* CreateSourceL(TSourceType aSourceType, HBufC8* aDes);

public:

	MDataSource* iSource;

	MDataSink* iSink;

	};

class TFileTestStep : public TTestStep

	{

public:

	TFileTestStep()

	: iFileFailureExpected(EFalse)

	{ }

	TFileTestStep(MDataSource* aSource)

	: TTestStep(aSource), iFileFailureExpected(EFalse)

	{ }

	TFileTestStep(MDataSink* aSink)

	: TTestStep(aSink), iFileFailureExpected(EFalse)

	{ }

	TFileTestStep(MDataSource* aSource, MDataSink* aSink)

	: TTestStep(aSource, aSink), iFileFailureExpected(EFalse)

	{ }

	TVerdict DoTestPostambleL(TBool aCheck);

public:

	TBool iFileFailureExpected;

	};

class TReadBufferTestStep : public TFileTestStep

	{

	public:

		TReadBufferTestStep(MDataSource* aSource, CMMFBuffer* aBuffer, TInt aPosition, const TDes8& aSourceDes)

		: TFileTestStep(aSource), iBuffer(aBuffer), iPosition(aPosition), iSourceDes(aSourceDes), iAsynchronousRead(EFalse)

		{ InitRandomNumberGenerator(); }

		TReadBufferTestStep(MDataSource* aSource, CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aSink, const TDes8& aSourceDes)

		: TFileTestStep(aSource, aSink), iBuffer(aBuffer), iPosition(aPosition), iSourceDes(aSourceDes), iAsynchronousRead(EFalse)

		{ InitRandomNumberGenerator(); }

		void InitRandomNumberGenerator()

			{

			TTime seedTime;

			seedTime.UniversalTime();

			iSeed = seedTime.Int64();

			}

		void SetPosition(TInt aPosition)

		{ iPosition = aPosition; }

		void SetAsynchronousRead(TBool aAsynchronousRead)

		{ iAsynchronousRead = aAsynchronousRead; }

		void RandomiseBuffer();

		TInt CheckBuffer();

	public:

		CMMFBuffer* iBuffer;

		TInt64 iSeed;

		TInt iPosition;

		const TDes8& iSourceDes;

		TBool iAsynchronousRead;

	};

class TWriteBufferTestStep : public TFileTestStep

	{

	public:

		TWriteBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer)

		: TFileTestStep(aSink), iBuffer(aBuffer), iPosition(0), iAsynchronousWrite(EFalse)

		{ InitRandomNumberGenerator(); }

		TWriteBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition)

		: TFileTestStep(aSink), iBuffer(aBuffer), iPosition(aPosition), iAsynchronousWrite(EFalse)

		{ InitRandomNumberGenerator(); }

		TWriteBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, MDataSource* aSource)

		: TFileTestStep(aSource, aSink), iBuffer(aBuffer), iPosition(0), iAsynchronousWrite(EFalse)

		{ InitRandomNumberGenerator(); }

		TWriteBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSource)

		: TFileTestStep(aSource, aSink), iBuffer(aBuffer), iPosition(aPosition), iAsynchronousWrite(EFalse)

		{ InitRandomNumberGenerator(); }

		void InitRandomNumberGenerator()

			{

			TTime seedTime;

			seedTime.UniversalTime();

			iSeed = seedTime.Int64();

			}

		void SetPosition(TInt aPosition)

		{ iPosition = aPosition; }

		void SetAsynchronousWrite(TBool aAsynchronousWrite)

		{ iAsynchronousWrite = aAsynchronousWrite; }

		void RandomiseBuffer();

		TVerdict DoTestPostambleL(TBool aCheck);

		virtual TInt CheckDestinationL() = 0;

	public:

		CMMFBuffer* iBuffer;

		TInt64 iSeed;

		TInt iPosition;

		TBool iAsynchronousWrite;

	};

class TWriteBufferToDescriptorTestStep : public TWriteBufferTestStep

	{

	public:

		TWriteBufferToDescriptorTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer), iDestinationDes(aDestinationDes), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToDescriptorTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aPosition), iDestinationDes(aDestinationDes), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToDescriptorTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, MDataSource* aSource, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aSource), iDestinationDes(aDestinationDes), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToDescriptorTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSource, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aPosition, aSource), iDestinationDes(aDestinationDes), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TInt CheckDestinationL();

	public:

		const TDes8& iDestinationDes;

		TDes8& iCopyOfDestinationDes;

	};

class TWriteBufferToFileTestStep : public TWriteBufferTestStep

	{

	public:

		TWriteBufferToFileTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer), iFsSession(aFsSession), iDestinationFileName(aDestinationFileName), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToFileTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aPosition), iFsSession(aFsSession), iDestinationFileName(aDestinationFileName), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToFileTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, MDataSource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aSource), iFsSession(aFsSession), iDestinationFileName(aDestinationFileName), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TWriteBufferToFileTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes)

		: TWriteBufferTestStep(aSink, aBuffer, aPosition, aSource), iFsSession(aFsSession), iDestinationFileName(aDestinationFileName), iCopyOfDestinationDes(aCopyOfDestinationDes)

		{ }

		TInt CheckDestinationL();

		void DoTestPreambleL();

	public:

		RFs& iFsSession;

		const TFileName& iDestinationFileName;

		TDes8& iCopyOfDestinationDes;

	};

class TNewSourceTestStep : public TFileTestStep

	{

public:

	TNewSourceTestStep(TUid aUid, TDesC8& aConfigDes)

	: iUid(aUid), iConfigDes(&aConfigDes)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iUid;

	TDesC8* iConfigDes;

	};

class TSourceTypeTestStep : public TTestStep

	{

public:

	TSourceTypeTestStep(MDataSource* aSource, TUid aUid, TFourCC aFourCC, TBool aCanSetSourceDataType)

	: TTestStep(aSource), iUid(aUid), iFourCC(aFourCC), iCanSetSourceDataType(aCanSetSourceDataType)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iUid;

	TFourCC iFourCC;

	TBool iCanSetSourceDataType;

	};

class TCanCreateSourceBufferTestStep : public TTestStep

	{

public:

	TCanCreateSourceBufferTestStep(MDataSource* aSource, TBool aCanCreateSourceBuffer)

	: TTestStep(aSource), iCanCreateSourceBuffer(aCanCreateSourceBuffer)

	{ }

	TVerdict DoTestStepL();

public:

	TBool iCanCreateSourceBuffer;

	};

class TSourceSampleConvertTestStep : public TTestStep

	{

public:

	TSourceSampleConvertTestStep(MDataSource* aSource, TBool aSourceSampleConvert)

	: TTestStep(aSource), iSourceSampleConvert(aSourceSampleConvert)

	{ }

	TVerdict DoTestStepL();

public:

	TBool iSourceSampleConvert;

	};

class TCreateSourceBuffer1TestStep : public TTestStep, public MAsyncEventHandler

	{

public:

	TCreateSourceBuffer1TestStep(TSourceType aSourceType, MDataSink* aSink, TUid aExpectedType, TBool aExpectedRef, TInt aExpectedMaxLength = 0)

	: TTestStep(NULL, aSink), iSourceType(aSourceType), iExpectedType(aExpectedType), iExpectedRef(aExpectedRef), iExpectedMaxLength(aExpectedMaxLength)

	{ }

	TVerdict DoTestStepL();

	TInt SendEventToClient(const TMMFEvent& aEvent);

public:

	TSourceType iSourceType;

	CMMFBuffer* iSinkBuffer;

	TUid iExpectedType;

	TBool iExpectedRef;

	TInt iExpectedMaxLength;

};

class TCreateSourceBuffer2TestStep : public TTestStep, public MAsyncEventHandler

	{

public:

	TCreateSourceBuffer2TestStep(TSourceType aSourceType, MDataSink* aSink, CMMFBuffer* aSinkBuffer, TUid aExpectedType, TBool aExpectedRef, TInt aExpectedMaxLength = 0)

	: TTestStep(NULL, aSink), iSourceType(aSourceType), iSinkBuffer(aSinkBuffer), iExpectedType(aExpectedType), iExpectedRef(aExpectedRef), iExpectedMaxLength(aExpectedMaxLength)

	{ }

	TVerdict DoTestStepL();

	TInt SendEventToClient(const TMMFEvent& aEvent);

public:

	TSourceType iSourceType;

	CMMFBuffer* iSinkBuffer;

	TUid iExpectedType;

	TBool iExpectedRef;

	TInt iExpectedMaxLength;

};

class TSourceThreadLogonTestStep : public TFileTestStep

	{

public:

	TSourceThreadLogonTestStep(MDataSource* aSource, MAsyncEventHandler* aEventHandler)

	: TFileTestStep(aSource), iEventHandler(aEventHandler)

	{ }

	TVerdict DoTestStepL();

public:

	MAsyncEventHandler* iEventHandler;

	};

class TNegotiateSourceTestStep : public TTestStep

	{

public:

	TNegotiateSourceTestStep(MDataSource* aSource, MDataSink* aSink)

	: TTestStep(aSource, aSink)

	{ }

	TVerdict DoTestStepL();

	};

class TFillBufferTestStep : public TReadBufferTestStep

	{

public:

	TFillBufferTestStep(MDataSource* aSource, CMMFBuffer* aBuffer, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TReadBufferTestStep(aSource, aBuffer, 0, aSink, aSourceDes), iReadLength(aReadLength)

	{ }

	void SetReadLength(TInt aReadLength)

	{ iReadLength = aReadLength; }

	TVerdict DoTestStepL();

public:

	TInt iReadLength;

	};

class TFillLastBufferTestStep : public TReadBufferTestStep

	{

public:

	TFillLastBufferTestStep(TUid aSourceUid, TDesC8& aConfigDes, CMMFDummySink* aSink, const TDes8& aSourceDes)

	: TReadBufferTestStep(NULL, NULL, 0, aSink, aSourceDes), iSourceUid(aSourceUid), iConfigDes(aConfigDes)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iSourceUid;

	TDesC8 &iConfigDes;

	};

class TReadLastBufferTestStep : public TReadBufferTestStep

	{

public:

	TReadLastBufferTestStep(CMMFClip* aClip, CMMFDummySink* aSink, const TDes8& aSourceDes)

	: TReadBufferTestStep(aClip, NULL, 0, aSink, aSourceDes)

	{ }

	TVerdict DoTestStepL();

	};

class TReadLastBuffer2TestStep : public TReadBufferTestStep

	{

public:

	TReadLastBuffer2TestStep(CMMFClip* aClip, CMMFDummySink* aSink, const TDes8& aSourceDes)

	: TReadBufferTestStep(aClip, NULL, 0, aSink, aSourceDes)

	{ }

	TVerdict DoTestStepL();

	};

class TReadLastBuffer3TestStep : public TReadBufferTestStep

	{

public:

	TReadLastBuffer3TestStep(CMMFClip* aClip, const TDes8& aSourceDes)

	: TReadBufferTestStep(aClip, NULL, 0, NULL, aSourceDes)

	{ }

	TVerdict DoTestStepL();

	};

class TNewSinkTestStep : public TFileTestStep

	{

public:

	TNewSinkTestStep(TUid aUid, TDesC8& aConfigDes)

	: iUid(aUid), iConfigDes(&aConfigDes)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iUid;

	TDesC8* iConfigDes;

	};

class TSinkTypeTestStep : public TTestStep

	{

public:

	TSinkTypeTestStep(MDataSink* aSink, TUid aUid, TFourCC aFourCC, TBool aCanSetSinkDataType)

	: TTestStep(aSink), iUid(aUid), iFourCC(aFourCC), iCanSetSinkDataType(aCanSetSinkDataType)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iUid;

	TFourCC iFourCC;

	TBool iCanSetSinkDataType;

	};

class TCanCreateSinkBufferTestStep : public TTestStep

	{

public:

	TCanCreateSinkBufferTestStep(MDataSink* aSink, TBool aCanCreateSinkBuffer)

	: TTestStep(aSink), iCanCreateSinkBuffer(aCanCreateSinkBuffer)

	{ }

	TVerdict DoTestStepL();

public:

	TBool iCanCreateSinkBuffer;

	};

class TCreateSinkBufferTestStep0 : public TTestStep

	{

public:

	TCreateSinkBufferTestStep0(MDataSink* aSink, TUid aExpectedType, TBool aExpectedRef, TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

	: TTestStep(aSource, aSink), iExpectedType(aExpectedType), iExpectedRef(aExpectedRef), iExpectedMaxLength(aExpectedMaxLength)

	{ }

	TVerdict DoTestStepL();

public:

	TUid iExpectedType;

	TBool iExpectedRef;

	CMMFFormatDecode* iFormat;

	TInt iExpectedMaxLength;

	};

class TCreateSinkBufferTestStep : public TTestStep

	{

public:

	TCreateSinkBufferTestStep(TUid aExpectedType, TBool aExpectedRef, CMMFFormatDecode* aFormat,

							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

		: TTestStep(aSource, NULL), iExpectedType(aExpectedType), iExpectedRef(aExpectedRef), iFormat(aFormat), iExpectedMaxLength(aExpectedMaxLength)

		{

		}

	TVerdict DoTestPostambleL(TBool aCheck);

public:

	TUid iExpectedType;

	TBool iExpectedRef;

	CMMFFormatDecode* iFormat;

	TInt iExpectedMaxLength;

	};

class TCreateSinkBufferTestStep1 : public TCreateSinkBufferTestStep 

	{

public:

	TCreateSinkBufferTestStep1(TUid aExpectedType, TBool aExpectedRef, CMMFFormatDecode* aFormat,

							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

		: TCreateSinkBufferTestStep(aExpectedType, aExpectedRef, aFormat, aExpectedMaxLength, aSource)

		{

		}

	TVerdict DoTestStepL();

	};

class TCreateSinkBufferTestStep2 : public TCreateSinkBufferTestStep 

	{

public:

	TCreateSinkBufferTestStep2(TUid aExpectedType, TBool aExpectedRef, CMMFFormatDecode* aFormat,

							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

		: TCreateSinkBufferTestStep(aExpectedType, aExpectedRef, aFormat, aExpectedMaxLength, aSource)

		{

		}

	TVerdict DoTestStepL();

	};

class TCreateSinkBufferTestStep3 : public TCreateSinkBufferTestStep 

	{

public:

	TCreateSinkBufferTestStep3(TUid aExpectedType, TBool aExpectedRef, CMMFFormatDecode* aFormat,

							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

		: TCreateSinkBufferTestStep(aExpectedType, aExpectedRef, aFormat, aExpectedMaxLength, aSource)

		{

		}

	TVerdict DoTestStepL();

	};

class TCreateSinkBufferTestStep4 : public TCreateSinkBufferTestStep 

	{

public:

	TCreateSinkBufferTestStep4(TUid aExpectedType, TBool aExpectedRef, CMMFFormatDecode* aFormat,

							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

		: TCreateSinkBufferTestStep(aExpectedType, aExpectedRef, aFormat, aExpectedMaxLength, aSource)

		{

		}

	TVerdict DoTestStepL();

	};

class TSinkThreadLogonTestStep : public TFileTestStep

	{

public:

	TSinkThreadLogonTestStep(MDataSink* aSink, MAsyncEventHandler* aEventHandler)

	: TFileTestStep(aSink), iEventHandler(aEventHandler)

	{ }

	TVerdict DoTestStepL();

public:

	MAsyncEventHandler* iEventHandler;

	};

class TNegotiateTestStep : public TTestStep

	{

public:

	TNegotiateTestStep(MDataSink* aSink, MDataSource* aSource)

	: TTestStep(aSource, aSink)

	{ }

	TVerdict DoTestStepL();

	};

class TEmptyBufferTestStep : public TWriteBufferToDescriptorTestStep

	{

public:

	TEmptyBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, CMMFDummySource* aSource, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes)

	: TWriteBufferToDescriptorTestStep(aSink, aBuffer, aSource, aDestinationDes, aCopyOfDestinationDes), iWriteLength((aBuffer != NULL) ? aBuffer->BufferSize() : 0)

	{ }

	void SetWriteLength(TInt aWriteLength)

	{ iWriteLength = aWriteLength; }

	TVerdict DoTestStepL();

public:

	TInt iWriteLength;

	};

class TClipBytesFreeTestStep : public TFileTestStep

	{

public:

	TClipBytesFreeTestStep(CMMFClip* aClip, TInt64 aExpectedBytesFree)

	: TFileTestStep(aClip, aClip), iExpectedBytesFree(aExpectedBytesFree)

	{ }

	TVerdict DoTestStepL();

public:

	TInt64 iExpectedBytesFree;

	};

class TClipSizeTestStep : public TFileTestStep

	{

public:

	TClipSizeTestStep(CMMFClip* aClip, TInt aExpectedSize)

	: TFileTestStep(aClip, aClip), iExpectedSize(aExpectedSize)

	{ }

	TVerdict DoTestStepL();

public:

	TInt iExpectedSize;

	};

class TClipSetSizeTestStep : public TFileTestStep

	{

public:

	TClipSetSizeTestStep(CMMFClip* aClip, TBool aCanSetSize)

	: TFileTestStep(aClip, aClip), iCanSetSize(aCanSetSize)

	{ }

	TVerdict DoTestStepL();

public:

	TBool iCanSetSize;

	};

class TClipDeleteTestStep : public TFileTestStep

	{

public:

	TClipDeleteTestStep(CMMFClip* aClip)

	: TFileTestStep(aClip, aClip)

	{ }

	TVerdict DoTestStepL();

	};

class TClipReadBufferTestStep : public TReadBufferTestStep

	{

public:

	TClipReadBufferTestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TReadBufferTestStep(aClip, aBuffer, aPosition, aSink, aSourceDes), iReadLength(aReadLength)

	{ }

	void SetReadLength(TInt aReadLength)

	{ iReadLength = aReadLength; }

	TVerdict DoTestStepL();

public:

	TInt iReadLength;

	};

class TClipReadBuffer2TestStep : public TReadBufferTestStep

	{

public:

	TClipReadBuffer2TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TReadBufferTestStep(aClip, aBuffer, aPosition, aSink, aSourceDes), iReadLength(aReadLength)

	{ }

	void SetReadLength(TInt aReadLength)

	{ iReadLength = aReadLength; }

	TVerdict DoTestStepL();

public:

	TInt iReadLength;

	};

class TClipReadBuffer3TestStep : public TReadBufferTestStep

	{

public:

	TClipReadBuffer3TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TReadBufferTestStep(aClip, aBuffer, aPosition, aSourceDes), iReadLength(aReadLength)

	{ }

	void SetReadLength(TInt aReadLength)

	{ iReadLength = aReadLength; }

	TVerdict DoTestStepL();

public:

	TInt iReadLength;

	};

class TClipReadBuffer4TestStep : public TReadBufferTestStep

	{

public:

	TClipReadBuffer4TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TReadBufferTestStep(aClip, aBuffer, aPosition, aSink, aSourceDes), iReadLength(aReadLength), iExpectedReadLength(aReadLength)

	{ }

	void SetReadLength(TInt aReadLength)

	{ iReadLength = aReadLength; }

	void SetExpectedReadLength(TInt aExpectedReadLength)

	{ iExpectedReadLength = aExpectedReadLength; }

	TVerdict DoTestStepL();

public:

	TInt iReadLength;

	TInt iExpectedReadLength;

	};

class TDescriptorClipWriteBufferTestStep : public TWriteBufferToDescriptorTestStep

	{

public:

	TDescriptorClipWriteBufferTestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

	: TWriteBufferToDescriptorTestStep(aClip, aBuffer, aPosition, aSource, aDestinationDes, aCopyOfDestinationDes), iWriteLength(aWriteLength)

	{ }

	void SetWriteLength(TInt aWriteLength)

	{ iWriteLength = aWriteLength; }

	TVerdict DoTestStepL();

public:

	TInt iWriteLength;

	};

class TDescriptorClipWriteBuffer2TestStep : public TWriteBufferToDescriptorTestStep

	{

public:

	TDescriptorClipWriteBuffer2TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

	: TWriteBufferToDescriptorTestStep(aClip, aBuffer, aPosition, aSource, aDestinationDes, aCopyOfDestinationDes), iWriteLength(aWriteLength)

	{ }

	void SetWriteLength(TInt aWriteLength)

	{ iWriteLength = aWriteLength; }

	TVerdict DoTestStepL();

public:

	TInt iWriteLength;

	};

class TDescriptorClipWriteBuffer3TestStep : public TWriteBufferToDescriptorTestStep

	{

public:

	TDescriptorClipWriteBuffer3TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, const TDes8& aDestinationDes, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

	: TWriteBufferToDescriptorTestStep(aClip, aBuffer, aPosition, aDestinationDes, aCopyOfDestinationDes), iWriteLength(aWriteLength)

	{ }

	void SetWriteLength(TInt aWriteLength)

	{ iWriteLength = aWriteLength; }

	TVerdict DoTestStepL();

public:

	TInt iWriteLength;

	};

class TNewFileSourceTestStep : public TNewSourceTestStep

	{

public:

	TNewFileSourceTestStep(TUid aUid, TDesC8& aConfigDes)

	: TNewSourceTestStep(aUid, aConfigDes)

	{ }

	TVerdict DoTestStepL();

	};

class TFileSourceThreadLogonTestStep : public TSourceThreadLogonTestStep

	{

public:

	TFileSourceThreadLogonTestStep(MDataSource* aSource, MAsyncEventHandler* aEventHandler, TInt aFileSize)

	: TSourceThreadLogonTestStep(aSource, aEventHandler), iFileSize(aFileSize)

	{ }

	TVerdict DoTestStepL();

public:

	TInt iFileSize;

	};

class TFileFillBufferTestStep : public TFillBufferTestStep

	{

public:

	TFileFillBufferTestStep(TSourceType aSourceType, TDesC& aFileName, CMMFBuffer* aBuffer, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

	: TFillBufferTestStep(NULL, aBuffer, aSink, aSourceDes, aReadLength), iFileName(aFileName), iSourceType(aSourceType)

	{ }

	TVerdict DoTestStepL();

public:

	TDesC& iFileName;

	TSourceType iSourceType;

	};

class TFileFillBuffer2TestStep : public TFileFillBufferTestStep

	{

public:

	TFileFillBuffer2TestStep(TSourceType aSourceType, TDesC& aFileName, CMMFBuffer* aBuffer, CMMFDummySink* aSink, const TDes8& aSourceDes)

	: TFileFillBufferTestStep(aSourceType, aFileName, aBuffer, aSink, aSourceDes)

	{ }

	TVerdict DoTestStepL();

	};

class TFileFillBuffer3TestStep : public TFileFillBufferTestStep

	{

public:

	TFileFillBuffer3TestStep(TSourceType aSourceType, TDesC& aFileName, RPointerArray<CMMFBuffer>* aBufferArray, CMMFDummySink* aSink, const TDes8& aSourceDes, TInt aReadLength = 0)

	: TFileFillBufferTestStep(aSourceType, aFileName, NULL, aSink, aSourceDes, aReadLength), iBufferArray(aBufferArray), iMaxRequestCount(20)

	{ }

	void SetMaxRequestCount(TInt aMaxRequestCount)

	{ iMaxRequestCount = aMaxRequestCount; }

	TVerdict DoTestStepL();

public:

	RPointerArray<CMMFBuffer>* iBufferArray;

	TInt iMaxRequestCount;

	};

class TFileFillBuffer4TestStep : public TFillBufferTestStep

	{

public:

	TFileFillBuffer4TestStep(MDataSource* aSource, RPointerArray<CMMFBuffer>* aBufferArray, CMMFDummySink* aSink, const TDes8& aSourceDes, TInt aReadLength = 0)

	: TFillBufferTestStep(aSource, NULL, aSink, aSourceDes, aReadLength), iBufferArray(aBufferArray), iMaxRequestCount(3)

	{ }

	void SetMaxRequestCount(TInt aMaxRequestCount)