Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/srssnk/TSU_MMF

     1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #ifndef __TSU_MMF_SRSSNK_H__

    17 #define __TSU_MMF_SRSSNK_H__

    19 #include <e32math.h>

    21 #include <testframework.h>

    22 #include <mmf/server/mmfdatapath.h>

    24 #include "CmmfTestControllerUIDs.hrh"

    25 #include <mmf/plugin/mmfformatimplementationuids.hrh>

    26 #include "TS_Codes.h"

    28 #include <mmf/common/mmffourcc.h>

    29 #include <mmf/common/mmfcontroller.h>

    30 #include <mmf/server/mmfdes.h>

    31 #include <mmf/server/mmffile.h>

    32 #include <mmf/server/mmfurl.h>

    33 #include <mmf/server/mmfaudioinput.h>

    34 #include <mmf/server/mmfaudiooutput.h>

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

    37 const TInt KTestBufferSize = 1032; // 1024 + 8

    38 const TInt KTestDataSize = 51200; // 50K

    39 const TInt KTestOverDataSize = KTestDataSize + 20;

    41 const TInt KTestReadSize = KTestBufferSize/2;

    42 const TInt KTestOverReadSize = KTestBufferSize + 10;

    44 const TInt KTestWriteSize = KTestBufferSize/2;

    45 const TInt KTestOverWriteSize = KTestBufferSize + 10;

    47 class CTestSuite;

    48 class CTestSuite_MMF_SRSSNK;

    50 enum TSourceType

    51 	{

    52 	ESourceTypeDes,

    53 	ESourceTypeFile,

    54 	ESourceTypeFileHandle,

    55 	ESourceTypeAudio

    56 	};

    58 enum TSinkType

    59 	{

    60 	ESinkTypeFile,

    61 	ESinkTypeFileHandle

    62 	};

    65 class TThreadData

    66 	{

    67 public:

    68 	TThreadData()

    69 	: iFileSize(-1), iErr(KErrNone)

    70 	{ }

    72 public:

    73 	CMMFFile* iFilePtr;

    74 	MAsyncEventHandler *iEventHandler;

    75 	TInt iFileSize;

    76 	TInt iErr;

    77 	};

    79 const TUid KTestDummyUid = { -1 };

    80 class CMMFTestBuffer : public CMMFBuffer

    81 	{

    82 public:

    83 	CMMFTestBuffer()

    84 	: CMMFBuffer(KTestDummyUid)

    85 	{ }

    87 	TUint BufferSize() const

    88 	{ return 0; }

    89 	};

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

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

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

    96 class CMMFDummySource : public CBase, public MDataSource, public MAsyncEventHandler

    97 	{

    98 public:

    99 	CMMFDummySource();

   101 	void SetExpectedEmptyCount(TInt aExpectedEmptyCount)

   102 	{ iExpectedEmptyCount = aExpectedEmptyCount; }

   104 	TBool BufferEmptiedOk()

   105 		{

   106 		TBool bufferEmptiedOk = iBufferEmptiedOk;

   107 		if (bufferEmptiedOk)

   108 			ResetBufferEmptiedOk();

   110 		return bufferEmptiedOk;

   111 		}

   113 	void ResetBufferEmptiedOk()

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

   116 	// From MDataSource

   117 	TFourCC SourceDataTypeCode(TMediaId aMediaId);

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

   119 	void BufferEmptiedL(CMMFBuffer* aBuffer);

   120 	TBool CanCreateSourceBuffer();

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

   123 	// MAsyncEventHandler

   124 	TInt SendEventToClient(const TMMFEvent& aEvent);

   126 	TInt Error()

   127 	{ ResetBufferEmptiedOk() ; return iError; }

   129 	TInt ErrorCount()

   130 	{ return iErrorCount; }

   132 	void SetFillBuffer()

   133 	{ iFillBuffer = ETrue; }

   135 	void SetActiveScheduler()

   136 	{ iActiveScheduler = CActiveScheduler::Current(); }

   138 	void ClearActiveScheduler()

   139 	{ iActiveScheduler = NULL; }

   141 	CMMFBuffer* MmfBuffer()

   142 	{ return iBuffer; }

   144 protected:

   145 	void ConstructSourceL(const TDesC8& aInitData);

   147 private:

   148 	TFourCC iSourceDataTypeCode;

   149 	TBool iBufferEmptiedOk;

   151 	TInt iEmptyCount;

   152 	TInt iExpectedEmptyCount;

   154 	CActiveScheduler *iActiveScheduler;

   155 	TInt iError;

   156 	TInt iErrorCount;

   158 	TBool iFillBuffer;

   160 	CMMFBuffer* iBuffer;	// buffer returned in BufferEmptiedL callback

   161 	};

   164 class CMMFDummySink : public CBase, public MDataSink, public MAsyncEventHandler

   165 	{

   166 public:

   167 	CMMFDummySink();

   169 	void SetExpectedFillCount(TInt aExpectedFillCount)

   170 	{ iExpectedFillCount = aExpectedFillCount; }

   172 	TBool BufferFilledOk()

   173 		{

   174 		TBool bufferFilledOk = iBufferFilledOk;

   175 		if (bufferFilledOk)

   176 			ResetBufferFilledOk();

   178 		return bufferFilledOk;

   179 		}

   181 	void ResetBufferFilledOk()

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

   184 	void BufferFilledError();

   186 	// From MDataSink

   187 	TFourCC SinkDataTypeCode(TMediaId aMediaId);

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

   189 	void BufferFilledL(CMMFBuffer* aBuffer);

   190 	TBool CanCreateSinkBuffer();

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

   193 	// MAsyncEventHandler

   194 	TInt SendEventToClient(const TMMFEvent& aEvent);

   196 	TInt Error()

   197 	{ ResetBufferFilledOk() ; return iError; }

   199 	TInt ErrorCount()

   200 	{ return iErrorCount; }

   202 	CMMFBuffer* MmfBuffer()

   203 	{ return iBuffer; }

   205 protected:

   206 	void ConstructSinkL(const TDesC8& aInitData);

   208 private:

   209 	TFourCC iSinkDataTypeCode;

   210 	TBool iBufferFilledOk;

   212 	TInt iFillCount;

   213 	TInt iExpectedFillCount;

   215 	CActiveScheduler *iActiveScheduler;

   216 	TInt iError;

   217 	TInt iErrorCount;

   219 	CMMFBuffer* iBuffer;	// buffer returned in BufferFilledL callback

   220 	};

   222 class TTestStep

   223 	{

   224 public:

   225 	TTestStep()

   226 	: iSource(NULL), iSink(NULL)

   227 	{ }

   229 	TTestStep(MDataSource* aSource)

   230 	: iSource(aSource), iSink(NULL)

   231 	{ }

   233 	TTestStep(MDataSink* aSink)

   234 	: iSource(NULL), iSink(aSink)

   235 	{ }

   237 	TTestStep(MDataSource* aSource, MDataSink* aSink)

   238 	: iSource(aSource), iSink(aSink)

   239 	{ }

   241 	virtual TVerdict DoTestStepL() = 0;

   243 	virtual void DoTestPreambleL();

   244 	virtual TVerdict DoTestPostambleL(TBool aCheck);

   245 	virtual TVerdict DoNegativeTestPostambleL();

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

   248 public:

   249 	MDataSource* iSource;

   250 	MDataSink* iSink;

   251 	};

   254 class TFileTestStep : public TTestStep

   255 	{

   256 public:

   257 	TFileTestStep()

   258 	: iFileFailureExpected(EFalse)

   259 	{ }

   261 	TFileTestStep(MDataSource* aSource)

   262 	: TTestStep(aSource), iFileFailureExpected(EFalse)

   263 	{ }

   265 	TFileTestStep(MDataSink* aSink)

   266 	: TTestStep(aSink), iFileFailureExpected(EFalse)

   267 	{ }

   269 	TFileTestStep(MDataSource* aSource, MDataSink* aSink)

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

   271 	{ }

   273 	TVerdict DoTestPostambleL(TBool aCheck);

   275 public:

   276 	TBool iFileFailureExpected;

   277 	};

   279 class TReadBufferTestStep : public TFileTestStep

   280 	{

   281 	public:

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

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

   284 		{ InitRandomNumberGenerator(); }

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

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

   288 		{ InitRandomNumberGenerator(); }

   290 		void InitRandomNumberGenerator()

   291 			{

   292 			TTime seedTime;

   293 			seedTime.UniversalTime();

   294 			iSeed = seedTime.Int64();

   295 			}

   297 		void SetPosition(TInt aPosition)

   298 		{ iPosition = aPosition; }

   300 		void SetAsynchronousRead(TBool aAsynchronousRead)

   301 		{ iAsynchronousRead = aAsynchronousRead; }

   303 		void RandomiseBuffer();

   304 		TInt CheckBuffer();

   306 	public:

   307 		CMMFBuffer* iBuffer;

   308 		TInt64 iSeed;

   310 		TInt iPosition;

   311 		const TDes8& iSourceDes;

   313 		TBool iAsynchronousRead;

   314 	};

   316 class TWriteBufferTestStep : public TFileTestStep

   317 	{

   318 	public:

   319 		TWriteBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer)

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

   321 		{ InitRandomNumberGenerator(); }

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

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

   325 		{ InitRandomNumberGenerator(); }

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

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

   329 		{ InitRandomNumberGenerator(); }

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

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

   333 		{ InitRandomNumberGenerator(); }

   335 		void InitRandomNumberGenerator()

   336 			{

   337 			TTime seedTime;

   338 			seedTime.UniversalTime();

   339 			iSeed = seedTime.Int64();

   340 			}

   342 		void SetPosition(TInt aPosition)

   343 		{ iPosition = aPosition; }

   345 		void SetAsynchronousWrite(TBool aAsynchronousWrite)

   346 		{ iAsynchronousWrite = aAsynchronousWrite; }

   348 		void RandomiseBuffer();

   350 		TVerdict DoTestPostambleL(TBool aCheck);

   351 		virtual TInt CheckDestinationL() = 0;

   353 	public:

   354 		CMMFBuffer* iBuffer;

   355 		TInt64 iSeed;

   357 		TInt iPosition;

   358 		TBool iAsynchronousWrite;

   359 	};

   361 class TWriteBufferToDescriptorTestStep : public TWriteBufferTestStep

   362 	{

   363 	public:

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

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

   366 		{ }

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

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

   370 		{ }

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

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

   374 		{ }

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

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

   378 		{ }

   380 		TInt CheckDestinationL();

   382 	public:

   383 		const TDes8& iDestinationDes;

   384 		TDes8& iCopyOfDestinationDes;

   385 	};

   387 class TWriteBufferToFileTestStep : public TWriteBufferTestStep

   388 	{

   389 	public:

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

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

   392 		{ }

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

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

   396 		{ }

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

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

   400 		{ }

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

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

   404 		{ }

   406 		TInt CheckDestinationL();

   407 		void DoTestPreambleL();

   409 	public:

   410 		RFs& iFsSession;

   411 		const TFileName& iDestinationFileName;

   412 		TDes8& iCopyOfDestinationDes;

   413 	};

   416 class TNewSourceTestStep : public TFileTestStep

   417 	{

   418 public:

   419 	TNewSourceTestStep(TUid aUid, TDesC8& aConfigDes)

   420 	: iUid(aUid), iConfigDes(&aConfigDes)

   421 	{ }

   423 	TVerdict DoTestStepL();

   425 public:

   426 	TUid iUid;

   427 	TDesC8* iConfigDes;

   428 	};

   431 class TSourceTypeTestStep : public TTestStep

   432 	{

   433 public:

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

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

   436 	{ }

   438 	TVerdict DoTestStepL();

   440 public:

   441 	TUid iUid;

   442 	TFourCC iFourCC;

   443 	TBool iCanSetSourceDataType;

   444 	};

   446 class TCanCreateSourceBufferTestStep : public TTestStep

   447 	{

   448 public:

   449 	TCanCreateSourceBufferTestStep(MDataSource* aSource, TBool aCanCreateSourceBuffer)

   450 	: TTestStep(aSource), iCanCreateSourceBuffer(aCanCreateSourceBuffer)

   451 	{ }

   453 	TVerdict DoTestStepL();

   455 public:

   456 	TBool iCanCreateSourceBuffer;

   457 	};

   459 class TSourceSampleConvertTestStep : public TTestStep

   460 	{

   461 public:

   462 	TSourceSampleConvertTestStep(MDataSource* aSource, TBool aSourceSampleConvert)

   463 	: TTestStep(aSource), iSourceSampleConvert(aSourceSampleConvert)

   464 	{ }

   466 	TVerdict DoTestStepL();

   468 public:

   469 	TBool iSourceSampleConvert;

   470 	};

   472 class TCreateSourceBuffer1TestStep : public TTestStep, public MAsyncEventHandler

   473 	{

   474 public:

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

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

   477 	{ }

   479 	TVerdict DoTestStepL();

   480 	TInt SendEventToClient(const TMMFEvent& aEvent);

   482 public:

   483 	TSourceType iSourceType;

   484 	CMMFBuffer* iSinkBuffer;

   485 	TUid iExpectedType;

   486 	TBool iExpectedRef;

   487 	TInt iExpectedMaxLength;

   488 };

   490 class TCreateSourceBuffer2TestStep : public TTestStep, public MAsyncEventHandler

   491 	{

   492 public:

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

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

   495 	{ }

   497 	TVerdict DoTestStepL();

   498 	TInt SendEventToClient(const TMMFEvent& aEvent);

   500 public:

   501 	TSourceType iSourceType;

   502 	CMMFBuffer* iSinkBuffer;

   503 	TUid iExpectedType;

   504 	TBool iExpectedRef;

   505 	TInt iExpectedMaxLength;

   506 };

   508 class TSourceThreadLogonTestStep : public TFileTestStep

   509 	{

   510 public:

   511 	TSourceThreadLogonTestStep(MDataSource* aSource, MAsyncEventHandler* aEventHandler)

   512 	: TFileTestStep(aSource), iEventHandler(aEventHandler)

   513 	{ }

   515 	TVerdict DoTestStepL();

   517 public:

   518 	MAsyncEventHandler* iEventHandler;

   519 	};

   521 class TNegotiateSourceTestStep : public TTestStep

   522 	{

   523 public:

   524 	TNegotiateSourceTestStep(MDataSource* aSource, MDataSink* aSink)

   525 	: TTestStep(aSource, aSink)

   526 	{ }

   528 	TVerdict DoTestStepL();

   529 	};

   531 class TFillBufferTestStep : public TReadBufferTestStep

   532 	{

   533 public:

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

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

   536 	{ }

   538 	void SetReadLength(TInt aReadLength)

   539 	{ iReadLength = aReadLength; }

   541 	TVerdict DoTestStepL();

   543 public:

   544 	TInt iReadLength;

   545 	};

   547 class TFillLastBufferTestStep : public TReadBufferTestStep

   548 	{

   549 public:

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

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

   552 	{ }

   554 	TVerdict DoTestStepL();

   556 public:

   557 	TUid iSourceUid;

   558 	TDesC8 &iConfigDes;

   559 	};

   561 class TReadLastBufferTestStep : public TReadBufferTestStep

   562 	{

   563 public:

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

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

   566 	{ }

   568 	TVerdict DoTestStepL();

   569 	};

   571 class TReadLastBuffer2TestStep : public TReadBufferTestStep

   572 	{

   573 public:

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

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

   576 	{ }

   578 	TVerdict DoTestStepL();

   579 	};

   581 class TReadLastBuffer3TestStep : public TReadBufferTestStep

   582 	{

   583 public:

   584 	TReadLastBuffer3TestStep(CMMFClip* aClip, const TDes8& aSourceDes)

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

   586 	{ }

   588 	TVerdict DoTestStepL();

   589 	};

   592 class TNewSinkTestStep : public TFileTestStep

   593 	{

   594 public:

   595 	TNewSinkTestStep(TUid aUid, TDesC8& aConfigDes)

   596 	: iUid(aUid), iConfigDes(&aConfigDes)

   597 	{ }

   599 	TVerdict DoTestStepL();

   601 public:

   602 	TUid iUid;

   603 	TDesC8* iConfigDes;

   604 	};

   607 class TSinkTypeTestStep : public TTestStep

   608 	{

   609 public:

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

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

   612 	{ }

   614 	TVerdict DoTestStepL();

   616 public:

   617 	TUid iUid;

   618 	TFourCC iFourCC;

   619 	TBool iCanSetSinkDataType;

   620 	};

   622 class TCanCreateSinkBufferTestStep : public TTestStep

   623 	{

   624 public:

   625 	TCanCreateSinkBufferTestStep(MDataSink* aSink, TBool aCanCreateSinkBuffer)

   626 	: TTestStep(aSink), iCanCreateSinkBuffer(aCanCreateSinkBuffer)

   627 	{ }

   629 	TVerdict DoTestStepL();

   631 public:

   632 	TBool iCanCreateSinkBuffer;

   633 	};

   635 class TCreateSinkBufferTestStep0 : public TTestStep

   636 	{

   637 public:

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

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

   640 	{ }

   642 	TVerdict DoTestStepL();

   644 public:

   645 	TUid iExpectedType;

   646 	TBool iExpectedRef;

   647 	CMMFFormatDecode* iFormat;

   648 	TInt iExpectedMaxLength;

   649 	};

   651 class TCreateSinkBufferTestStep : public TTestStep

   652 	{

   653 public:

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

   655 							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

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

   657 		{

   658 		}

   660 	TVerdict DoTestPostambleL(TBool aCheck);

   662 public:

   663 	TUid iExpectedType;

   664 	TBool iExpectedRef;

   665 	CMMFFormatDecode* iFormat;

   666 	TInt iExpectedMaxLength;

   667 	};

   669 class TCreateSinkBufferTestStep1 : public TCreateSinkBufferTestStep

   670 	{

   671 public:

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

   673 							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

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

   675 		{

   676 		}

   678 	TVerdict DoTestStepL();

   679 	};

   681 class TCreateSinkBufferTestStep2 : public TCreateSinkBufferTestStep

   682 	{

   683 public:

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

   685 							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

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

   687 		{

   688 		}

   690 	TVerdict DoTestStepL();

   691 	};

   693 class TCreateSinkBufferTestStep3 : public TCreateSinkBufferTestStep

   694 	{

   695 public:

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

   697 							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

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

   699 		{

   700 		}

   702 	TVerdict DoTestStepL();

   703 	};

   705 class TCreateSinkBufferTestStep4 : public TCreateSinkBufferTestStep

   706 	{

   707 public:

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

   709 							  TInt aExpectedMaxLength = 0, CMMFDummySource* aSource = NULL)

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

   711 		{

   712 		}

   714 	TVerdict DoTestStepL();

   715 	};

   717 class TSinkThreadLogonTestStep : public TFileTestStep

   718 	{

   719 public:

   720 	TSinkThreadLogonTestStep(MDataSink* aSink, MAsyncEventHandler* aEventHandler)

   721 	: TFileTestStep(aSink), iEventHandler(aEventHandler)

   722 	{ }

   724 	TVerdict DoTestStepL();

   726 public:

   727 	MAsyncEventHandler* iEventHandler;

   728 	};

   730 class TNegotiateTestStep : public TTestStep

   731 	{

   732 public:

   733 	TNegotiateTestStep(MDataSink* aSink, MDataSource* aSource)

   734 	: TTestStep(aSource, aSink)

   735 	{ }

   737 	TVerdict DoTestStepL();

   738 	};

   740 class TEmptyBufferTestStep : public TWriteBufferToDescriptorTestStep

   741 	{

   742 public:

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

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

   745 	{ }

   747 	void SetWriteLength(TInt aWriteLength)

   748 	{ iWriteLength = aWriteLength; }

   750 	TVerdict DoTestStepL();

   752 public:

   753 	TInt iWriteLength;

   754 	};

   757 class TClipBytesFreeTestStep : public TFileTestStep

   758 	{

   759 public:

   760 	TClipBytesFreeTestStep(CMMFClip* aClip, TInt64 aExpectedBytesFree)

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

   762 	{ }

   764 	TVerdict DoTestStepL();

   766 public:

   767 	TInt64 iExpectedBytesFree;

   768 	};

   770 class TClipSizeTestStep : public TFileTestStep

   771 	{

   772 public:

   773 	TClipSizeTestStep(CMMFClip* aClip, TInt aExpectedSize)

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

   775 	{ }

   777 	TVerdict DoTestStepL();

   779 public:

   780 	TInt iExpectedSize;

   781 	};

   783 class TClipSetSizeTestStep : public TFileTestStep

   784 	{

   785 public:

   786 	TClipSetSizeTestStep(CMMFClip* aClip, TBool aCanSetSize)

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

   788 	{ }

   790 	TVerdict DoTestStepL();

   792 public:

   793 	TBool iCanSetSize;

   794 	};

   796 class TClipDeleteTestStep : public TFileTestStep

   797 	{

   798 public:

   799 	TClipDeleteTestStep(CMMFClip* aClip)

   800 	: TFileTestStep(aClip, aClip)

   801 	{ }

   803 	TVerdict DoTestStepL();

   804 	};

   806 class TClipReadBufferTestStep : public TReadBufferTestStep

   807 	{

   808 public:

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

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

   811 	{ }

   813 	void SetReadLength(TInt aReadLength)

   814 	{ iReadLength = aReadLength; }

   816 	TVerdict DoTestStepL();

   818 public:

   819 	TInt iReadLength;

   820 	};

   822 class TClipReadBuffer2TestStep : public TReadBufferTestStep

   823 	{

   824 public:

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

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

   827 	{ }

   829 	void SetReadLength(TInt aReadLength)

   830 	{ iReadLength = aReadLength; }

   832 	TVerdict DoTestStepL();

   834 public:

   835 	TInt iReadLength;

   836 	};

   838 class TClipReadBuffer3TestStep : public TReadBufferTestStep

   839 	{

   840 public:

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

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

   843 	{ }

   845 	void SetReadLength(TInt aReadLength)

   846 	{ iReadLength = aReadLength; }

   848 	TVerdict DoTestStepL();

   850 public:

   851 	TInt iReadLength;

   852 	};

   854 class TClipReadBuffer4TestStep : public TReadBufferTestStep

   855 	{

   856 public:

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

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

   859 	{ }

   861 	void SetReadLength(TInt aReadLength)

   862 	{ iReadLength = aReadLength; }

   864 	void SetExpectedReadLength(TInt aExpectedReadLength)

   865 	{ iExpectedReadLength = aExpectedReadLength; }

   867 	TVerdict DoTestStepL();

   869 public:

   870 	TInt iReadLength;

   871 	TInt iExpectedReadLength;

   872 	};

   875 class TDescriptorClipWriteBufferTestStep : public TWriteBufferToDescriptorTestStep

   876 	{

   877 public:

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

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

   880 	{ }

   882 	void SetWriteLength(TInt aWriteLength)

   883 	{ iWriteLength = aWriteLength; }

   885 	TVerdict DoTestStepL();

   887 public:

   888 	TInt iWriteLength;

   889 	};

   891 class TDescriptorClipWriteBuffer2TestStep : public TWriteBufferToDescriptorTestStep

   892 	{

   893 public:

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

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

   896 	{ }

   898 	void SetWriteLength(TInt aWriteLength)

   899 	{ iWriteLength = aWriteLength; }

   901 	TVerdict DoTestStepL();

   903 public:

   904 	TInt iWriteLength;

   905 	};

   907 class TDescriptorClipWriteBuffer3TestStep : public TWriteBufferToDescriptorTestStep

   908 	{

   909 public:

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

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

   912 	{ }

   914 	void SetWriteLength(TInt aWriteLength)

   915 	{ iWriteLength = aWriteLength; }

   917 	TVerdict DoTestStepL();

   919 public:

   920 	TInt iWriteLength;

   921 	};

   923 class TNewFileSourceTestStep : public TNewSourceTestStep

   924 	{

   925 public:

   926 	TNewFileSourceTestStep(TUid aUid, TDesC8& aConfigDes)

   927 	: TNewSourceTestStep(aUid, aConfigDes)

   928 	{ }

   930 	TVerdict DoTestStepL();

   931 	};

   933 class TFileSourceThreadLogonTestStep : public TSourceThreadLogonTestStep

   934 	{

   935 public:

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

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

   938 	{ }

   940 	TVerdict DoTestStepL();

   942 public:

   943 	TInt iFileSize;

   944 	};

   946 class TFileFillBufferTestStep : public TFillBufferTestStep

   947 	{

   948 public:

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

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

   951 	{ }

   953 	TVerdict DoTestStepL();

   955 public:

   956 	TDesC& iFileName;

   957 	TSourceType iSourceType;

   958 	};

   960 class TFileFillBuffer2TestStep : public TFileFillBufferTestStep

   961 	{

   962 public:

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

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

   965 	{ }

   967 	TVerdict DoTestStepL();

   968 	};

   970 class TFileFillBuffer3TestStep : public TFileFillBufferTestStep

   971 	{

   972 public:

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

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

   975 	{ }

   977 	void SetMaxRequestCount(TInt aMaxRequestCount)

   978 	{ iMaxRequestCount = aMaxRequestCount; }

   980 	TVerdict DoTestStepL();

   982 public:

   983 	RPointerArray<CMMFBuffer>* iBufferArray;

   984 	TInt iMaxRequestCount;

   985 	};

   987 class TFileFillBuffer4TestStep : public TFillBufferTestStep

   988 	{

   989 public:

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

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

   992 	{ }

   994 	void SetMaxRequestCount(TInt aMaxRequestCount)

   995 	{ iMaxRequestCount = aMaxRequestCount; }

   997 	TVerdict DoTestStepL();

   999 public:

  1000 	RPointerArray<CMMFBuffer>* iBufferArray;

  1001 	TInt iMaxRequestCount;

  1002 	};

  1004 class TFileReadBufferTestStep : public TClipReadBufferTestStep

  1005 	{

  1006 public:

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

  1008 	: TClipReadBufferTestStep(NULL, aBuffer, aPosition, aSink, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName)

  1009 	{ }

  1011 	TVerdict DoTestStepL();

  1013 public:

  1014 	TSourceType iSourceType;

  1015 	const TDesC& iFileName;

  1017 	};

  1019 class TFileReadBuffer2TestStep : public TClipReadBuffer2TestStep

  1020 	{

  1021 public:

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

  1023 	: TClipReadBuffer2TestStep(NULL, aBuffer, aPosition, aSink, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName)

  1024 	{ }

  1026 	TVerdict DoTestStepL();

  1028 public:

  1029 	TSourceType iSourceType;

  1030 	const TDesC& iFileName;

  1031 	};

  1033 class TFileReadBuffer3TestStep : public TClipReadBuffer3TestStep

  1034 	{

  1035 public:

  1036 	TFileReadBuffer3TestStep(TSourceType aSourceType, const TDesC& aFileName, CMMFBuffer* aBuffer, TInt aPosition, const TDes8& aSourceDes, TUint aReadLength = 0)

  1037 	: TClipReadBuffer3TestStep(NULL, aBuffer, aPosition, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName)

  1038 	{ }

  1040 	void SetReadLength(TInt aReadLength)

  1041 	{ iReadLength = aReadLength; }

  1043 	TVerdict DoTestStepL();

  1045 public:

  1046 	TSourceType iSourceType;

  1047 	const TDesC& iFileName;

  1048 	};

  1050 class TFileReadBuffer4TestStep : public TClipReadBuffer4TestStep

  1051 	{

  1052 public:

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

  1054 	: TClipReadBuffer4TestStep(NULL, aBuffer, aPosition, aSink, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName)

  1055 	{ }

  1057 	TVerdict DoTestStepL();

  1059 public:

  1060 	TSourceType iSourceType;

  1061 	const TDesC& iFileName;

  1062 	};

  1064 class TFileReadBuffer5TestStep : public TClipReadBuffer4TestStep

  1065 	{

  1066 public:

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

  1068 	: TClipReadBuffer4TestStep(NULL, NULL, aPosition, aSink, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName), iBufferArray(aBufferArray), iMaxRequestCount(20)

  1069 	{ }

  1071 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1072 	{ iMaxRequestCount = aMaxRequestCount; }

  1074 	TVerdict DoTestStepL();

  1076 public:

  1077 	TSourceType iSourceType;

  1078 	const TDesC& iFileName;

  1079 	RPointerArray<CMMFBuffer>* iBufferArray;

  1080 	TInt iMaxRequestCount;

  1081 	};

  1083 class TFileReadBuffer6TestStep : public TClipReadBuffer4TestStep

  1084 	{

  1085 public:

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

  1087 	: TClipReadBuffer4TestStep(NULL, NULL, aPosition, aSink, aSourceDes, aReadLength), iSourceType(aSourceType), iFileName(aFileName), iBufferArray(aBufferArray), iMaxRequestCount(20)

  1088 	{ }

  1090 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1091 	{ iMaxRequestCount = aMaxRequestCount; }

  1093 	TVerdict DoTestStepL();

  1095 public:

  1096 	TSourceType iSourceType;

  1097 	const TDesC& iFileName;

  1098 	RPointerArray<CMMFBuffer>* iBufferArray;

  1099 	TInt iMaxRequestCount;

  1100 	};

  1102 class TFileReadBuffer7TestStep : public TClipReadBuffer4TestStep

  1103 	{

  1104 public:

  1105 	TFileReadBuffer7TestStep(CMMFClip* aSource, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

  1106 	: TClipReadBuffer4TestStep(aSource, NULL, aPosition, aSink, aSourceDes, aReadLength), iBufferArray(aBufferArray), iMaxRequestCount(3)

  1107 	{ }

  1109 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1110 	{ iMaxRequestCount = aMaxRequestCount; }

  1112 	TVerdict DoTestStepL();

  1114 public:

  1115 	RPointerArray<CMMFBuffer>* iBufferArray;

  1116 	TInt iMaxRequestCount;

  1117 	};

  1119 class TFileReadBuffer8TestStep : public TClipReadBuffer4TestStep

  1120 	{

  1121 public:

  1122 	TFileReadBuffer8TestStep(CMMFClip* aSource, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySink* aSink, const TDes8& aSourceDes, TUint aReadLength = 0)

  1123 	: TClipReadBuffer4TestStep(aSource, NULL, aPosition, aSink, aSourceDes, aReadLength), iBufferArray(aBufferArray), iMaxRequestCount(3)

  1124 	{ }

  1126 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1127 	{ iMaxRequestCount = aMaxRequestCount; }

  1129 	TVerdict DoTestStepL();

  1131 public:

  1132 	RPointerArray<CMMFBuffer>* iBufferArray;

  1133 	TInt iMaxRequestCount;

  1134 	};

  1137 class TNewFileSinkTestStep : public TNewSinkTestStep

  1138 	{

  1139 public:

  1140 	TNewFileSinkTestStep(TUid aUid, TDesC8& aConfigDes)

  1141 	: TNewSinkTestStep(aUid, aConfigDes)

  1142 	{ }

  1144 	TVerdict DoTestStepL();

  1145 	};

  1147 class TFileSinkSetSizeTestStep : public TClipSetSizeTestStep

  1148 	{

  1149 public:

  1150 	TFileSinkSetSizeTestStep(CMMFClip* aClip, TBool aCanSetSize)

  1151 	: TClipSetSizeTestStep(aClip, aCanSetSize)

  1152 	{ }

  1154 	TVerdict DoTestStepL();

  1155 	};

  1157 class TFileSinkThreadLogonTestStep : public TSinkThreadLogonTestStep

  1158 	{

  1159 public:

  1160 	TFileSinkThreadLogonTestStep(MDataSink* aSink, MAsyncEventHandler* aEventHandler, TInt aFileSize)

  1161 	: TSinkThreadLogonTestStep(aSink, aEventHandler), iFileSize(aFileSize)

  1162 	{ }

  1164 	TVerdict DoTestStepL();

  1166 public:

  1167 	TInt iFileSize;

  1168 	};

  1170 class TFileEmptyBufferTestStep : public TWriteBufferToFileTestStep

  1171 	{

  1172 public:

  1173 	TFileEmptyBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1174 	: TWriteBufferToFileTestStep(aSink, aBuffer, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes), iWriteLength((aBuffer != NULL) ? aBuffer->BufferSize() : 0)

  1175 	{ }

  1177 	void SetWriteLength(TInt aWriteLength)

  1178 	{ iWriteLength = aWriteLength; }

  1180 	TVerdict DoTestStepL();

  1182 public:

  1183 	TInt iWriteLength;

  1184 	};

  1186 class TFileEmptyBuffer2TestStep : public TFileEmptyBufferTestStep

  1187 	{

  1188 public:

  1189 	TFileEmptyBuffer2TestStep(TSinkType aSinkType, CMMFBuffer* aBuffer, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1190 	: TFileEmptyBufferTestStep(NULL, aBuffer, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes), iSinkType(aSinkType)

  1191 	{ }

  1193 	TVerdict DoTestStepL();

  1194 protected:

  1195 	TSinkType iSinkType;

  1196 	};

  1198 class TFileEmptyBuffer3TestStep : public TFileEmptyBuffer2TestStep

  1199 	{

  1200 public:

  1201 	TFileEmptyBuffer3TestStep(TSinkType aSinkType, CMMFBuffer* aBuffer, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1202 	: TFileEmptyBuffer2TestStep(aSinkType, aBuffer, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes)

  1203 	{ }

  1205 	TVerdict DoTestStepL();

  1207 	void DoTestPreambleL();

  1208 	TVerdict DoTestPostambleL(TBool aCheck);

  1209 	};

  1211 class TFileEmptyBuffer4TestStep : public TFileEmptyBuffer3TestStep

  1212 	{

  1213 public:

  1214 	TFileEmptyBuffer4TestStep(TSinkType aSinkType, RPointerArray<CMMFBuffer>* aBufferArray, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1215 	: TFileEmptyBuffer3TestStep(aSinkType, NULL, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes), iBufferArray(aBufferArray), iMaxRequestCount(20)

  1216 	{ }

  1218 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1219 	{ iMaxRequestCount = aMaxRequestCount; }

  1221 	TVerdict DoTestStepL();

  1223 	void DoTestPreambleL();

  1224 	TVerdict DoTestPostambleL(TBool aCheck);

  1226 public:

  1227 	RPointerArray<CMMFBuffer>* iBufferArray;

  1228 	TInt iMaxRequestCount;

  1229 	};

  1231 class TFileEmptyBuffer5TestStep : public TFileEmptyBuffer4TestStep

  1232 	{

  1233 public:

  1234 	TFileEmptyBuffer5TestStep(TSinkType aSinkType, RPointerArray<CMMFBuffer>* aBufferArray, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1235 	: TFileEmptyBuffer4TestStep(aSinkType, aBufferArray, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes)

  1236 	{ }

  1238 	TInt CheckDestinationL();

  1239 	};

  1241 class TFileEmptyBuffer6TestStep : public TFileEmptyBufferTestStep

  1242 	{

  1243 public:

  1244 	TFileEmptyBuffer6TestStep(MDataSink* aSink, RPointerArray<CMMFBuffer>* aBufferArray, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFile, TDes8& aCopyOfDestinationDes)

  1245 	: TFileEmptyBufferTestStep(aSink, NULL, aSource, aFsSession, aDestinationFile, aCopyOfDestinationDes), iBufferArray(aBufferArray), iMaxRequestCount(3)

  1246 	{ }

  1248 	TVerdict DoTestStepL();

  1249 	TInt CheckDestinationL();

  1251 public:

  1252 	RPointerArray<CMMFBuffer>* iBufferArray;

  1253 	TInt iMaxRequestCount;

  1254 	};

  1256 class TFileWriteBufferTestStep : public TWriteBufferToFileTestStep

  1257 	{

  1258 public:

  1259 	TFileWriteBufferTestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1260 	: TWriteBufferToFileTestStep(aClip, aBuffer, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iWriteLength(aWriteLength)

  1261 	{ iAsynchronousWrite = ETrue; }

  1263 	void SetWriteLength(TInt aWriteLength)

  1264 	{ iWriteLength = aWriteLength; }

  1266 	TVerdict DoTestStepL();

  1268 public:

  1269 	TInt iWriteLength;

  1270 	};

  1272 class TFileWriteBuffer2TestStep : public TFileWriteBufferTestStep

  1273 	{

  1274 public:

  1275 	TFileWriteBuffer2TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1276 	: TFileWriteBufferTestStep(aClip, aBuffer, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes, aWriteLength)

  1277 	{ iAsynchronousWrite = ETrue; }

  1279 	TVerdict DoTestStepL();

  1280 	};

  1282 class TFileWriteBuffer3TestStep : public TFileWriteBufferTestStep

  1283 	{

  1284 public:

  1285 	TFileWriteBuffer3TestStep(CMMFClip* aClip, CMMFBuffer* aBuffer, TInt aPosition, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1286 	: TFileWriteBufferTestStep(aClip, aBuffer, aPosition, NULL, aFsSession, aDestinationFileName, aCopyOfDestinationDes, aWriteLength)

  1287 	{ }

  1289 	TVerdict DoTestStepL();

  1290 	};

  1292 class TFileWriteBuffer4TestStep : public TWriteBufferToFileTestStep

  1293 	{

  1294 public:

  1295 	TFileWriteBuffer4TestStep(TSinkType aSinkType, TDesC& aFileName, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1296 	: TWriteBufferToFileTestStep(NULL, aBuffer, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iWriteLength(aWriteLength), iSinkType(aSinkType), iFileName(aFileName)

  1297 	{ iAsynchronousWrite = ETrue; }

  1299 	void SetWriteLength(TInt aWriteLength)

  1300 	{ iWriteLength = aWriteLength; }

  1302 	TVerdict DoTestStepL();

  1304 public:

  1305 	TInt iWriteLength;

  1306 	TSinkType iSinkType;

  1307 	TDesC& iFileName;

  1308 	};

  1310 class TFileWriteBuffer5TestStep : public TFileWriteBuffer4TestStep

  1311 	{

  1312 public:

  1313 	TFileWriteBuffer5TestStep(TSinkType aSinkType, TDesC& aFileName, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1314 	: TFileWriteBuffer4TestStep(aSinkType, aFileName, aBuffer, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes, aWriteLength)

  1315 	{ }

  1317 	TInt CheckDestinationL();

  1318 	TVerdict DoNegativeTestPostambleL();

  1319 	};

  1321 class TFileWriteBuffer6TestStep : public TWriteBufferToFileTestStep

  1322 	{

  1323 public:

  1324 	TFileWriteBuffer6TestStep(TSinkType aSinkType, TDesC& aFileName, CMMFBuffer* aBuffer, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1325 	: TWriteBufferToFileTestStep(NULL, aBuffer, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iWriteLength(aWriteLength), iSinkType(aSinkType), iFileName(aFileName)

  1326 	{ }

  1328 	void SetWriteLength(TInt aWriteLength)

  1329 	{ iWriteLength = aWriteLength; }

  1331 	TVerdict DoTestStepL();

  1333 public:

  1334 	TInt iWriteLength;

  1335 	TSinkType iSinkType;

  1336 	TDesC& iFileName;

  1337 	};

  1339 class TFileWriteBuffer7TestStep : public TWriteBufferToFileTestStep

  1340 	{

  1341 public:

  1342 	TFileWriteBuffer7TestStep(TSinkType aSinkType, TDesC& aFileName, CMMFBuffer* aBuffer, TInt aPosition, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1343 	: TWriteBufferToFileTestStep(NULL, aBuffer, aPosition, aFsSession, aDestinationFileName, aCopyOfDestinationDes),iSinkType(aSinkType), iFileName(aFileName), iWriteLength(aWriteLength)

  1344 	{ }

  1346 	void SetWriteLength(TInt aWriteLength)

  1347 	{ iWriteLength = aWriteLength; }

  1349 	TVerdict DoTestStepL();

  1351 public:

  1352 	TSinkType iSinkType;

  1353 	TDesC& iFileName;

  1354 	TInt iWriteLength;

  1355 	};

  1357 class TFileWriteBuffer8TestStep : public TWriteBufferToFileTestStep

  1358 	{

  1359 public:

  1360 	TFileWriteBuffer8TestStep(TSinkType aSinkType, TDesC& aFileName, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1361 	: TWriteBufferToFileTestStep(NULL, NULL, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iSinkType(aSinkType), iFileName(aFileName), iWriteLength(aWriteLength), iBufferArray(aBufferArray), iMaxRequestCount(20)

  1362 	{ }

  1364 	void SetWriteLength(TInt aWriteLength)

  1365 	{ iWriteLength = aWriteLength; }

  1367 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1368 	{ iMaxRequestCount = aMaxRequestCount; }

  1370 	TVerdict DoTestStepL();

  1372 public:

  1373 	TSinkType iSinkType;

  1374 	TDesC& iFileName;

  1375 	TInt iWriteLength;

  1376 	RPointerArray<CMMFBuffer>* iBufferArray;

  1377 	TInt iMaxRequestCount;

  1378 	};

  1380 class TFileWriteBuffer9TestStep : public TWriteBufferToFileTestStep

  1381 	{

  1382 public:

  1383 	TFileWriteBuffer9TestStep(TSinkType aSinkType, TDesC& aFileName, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1384 	: TWriteBufferToFileTestStep(NULL, NULL, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iFileName(aFileName), iWriteLength(aWriteLength), iBufferArray(aBufferArray), iMaxRequestCount(20), iSinkType(aSinkType)

  1385 	{ }

  1387 	void SetWriteLength(TInt aWriteLength)

  1388 	{ iWriteLength = aWriteLength; }

  1390 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1391 	{ iMaxRequestCount = aMaxRequestCount; }

  1393 	TVerdict DoTestStepL();

  1395 public:

  1396 	TDesC& iFileName;

  1397 	TInt iWriteLength;

  1398 	RPointerArray<CMMFBuffer>* iBufferArray;

  1399 	TInt iMaxRequestCount;

  1400 	TSinkType iSinkType;

  1401 	};

  1403 class TFileWriteBuffer10TestStep : public TFileWriteBuffer8TestStep

  1404 	{

  1405 public:

  1406 	TFileWriteBuffer10TestStep(TSinkType aSinkType, TDesC& aFileName, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1407 	: TFileWriteBuffer8TestStep(aSinkType, aFileName, aBufferArray, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes, aWriteLength)

  1408 	{ iMaxRequestCount = 3; }

  1410 	TInt CheckDestinationL();

  1411 	};

  1413 class TFileWriteBuffer11TestStep : public TFileWriteBuffer9TestStep

  1414 	{

  1415 public:

  1416 	TFileWriteBuffer11TestStep(TSinkType aSinkType, TDesC& aFileName, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1417 	: TFileWriteBuffer9TestStep(aSinkType, aFileName, aBufferArray, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes, aWriteLength)

  1418 	{ iMaxRequestCount = 3; }

  1420 	TInt CheckDestinationL();

  1421 	};

  1423 class TFileWriteBuffer12TestStep : public TWriteBufferToFileTestStep

  1424 	{

  1425 public:

  1426 	TFileWriteBuffer12TestStep(MDataSink* aSink, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1427 	: TWriteBufferToFileTestStep(aSink, NULL, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iWriteLength(aWriteLength), iBufferArray(aBufferArray), iMaxRequestCount(3)

  1428 	{ ASSERT(iBufferArray->Count() == 5); }

  1430 	void SetWriteLength(TInt aWriteLength)

  1431 	{ iWriteLength = aWriteLength; }

  1433 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1434 	{ iMaxRequestCount = aMaxRequestCount; }

  1436 	TVerdict DoTestStepL();

  1437 	TInt CheckDestinationL();

  1439 public:

  1440 	TInt iWriteLength;

  1442 	RPointerArray<CMMFBuffer>* iBufferArray;

  1443 	TInt iMaxRequestCount;

  1444 	};

  1446 class TFileWriteBuffer13TestStep : public TWriteBufferToFileTestStep

  1447 	{

  1448 public:

  1449 	TFileWriteBuffer13TestStep(MDataSink* aSink, RPointerArray<CMMFBuffer>* aBufferArray, TInt aPosition, CMMFDummySource* aSource, RFs& aFsSession, const TFileName& aDestinationFileName, TDes8& aCopyOfDestinationDes, TUint aWriteLength = 0)

  1450 	: TWriteBufferToFileTestStep(aSink, NULL, aPosition, aSource, aFsSession, aDestinationFileName, aCopyOfDestinationDes), iWriteLength(aWriteLength), iBufferArray(aBufferArray), iMaxRequestCount(3)

  1451 	{ ASSERT(iBufferArray->Count() == 5); }

  1453 	void SetWriteLength(TInt aWriteLength)

  1454 	{ iWriteLength = aWriteLength; }

  1456 	void SetMaxRequestCount(TInt aMaxRequestCount)

  1457 	{ iMaxRequestCount = aMaxRequestCount; }

  1459 	TVerdict DoTestStepL();

  1460 	TInt CheckDestinationL();

  1462 public:

  1463 	TInt iWriteLength;

  1465 	RPointerArray<CMMFBuffer>* iBufferArray;

  1466 	TInt iMaxRequestCount;

  1467 	};

  1469 class TAudioInputCreateSourceBuffer1TestStep : public TTestStep

  1470 	{

  1471 public:

  1472 	TAudioInputCreateSourceBuffer1TestStep(CMMFAudioInput* aSource)

  1473 	: TTestStep(aSource)

  1474 	{ }

  1476 	TVerdict DoTestStepL();

  1477 };

  1479 class TAudioInputCreateSourceBuffer2TestStep : public TTestStep

  1480 	{

  1481 public:

  1482 	TAudioInputCreateSourceBuffer2TestStep(CMMFAudioInput* aSource, CMMFBuffer* aSinkBuffer)

  1483 	: TTestStep(aSource), iSinkBuffer(aSinkBuffer)

  1484 	{ }

  1486 	TVerdict DoTestStepL();

  1488 public:

  1489 	CMMFBuffer* iSinkBuffer;

  1490 };

  1492 class TAudioInputFillBufferTestStep : public TTestStep

  1493 	{

  1494 public:

  1495 	TAudioInputFillBufferTestStep(MDataSource* aSource, CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1496 	: TTestStep(aSource, aSink), iBuffer(aBuffer)

  1497 	{ }

  1499 	TVerdict DoTestStepL();

  1501 public:

  1502 	CMMFBuffer* iBuffer;

  1503 	};

  1505 class TAudioInputFillBuffer2TestStep : public TAudioInputFillBufferTestStep

  1506 	{

  1507 public:

  1508 	TAudioInputFillBuffer2TestStep(MDataSource* aSource, CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1509 	: TAudioInputFillBufferTestStep(aSource, aBuffer, aSink)

  1510 	{ }

  1512 	TVerdict DoTestStepL();

  1513 	};

  1515 class TAudioInputFillBuffer3TestStep : public TAudioInputFillBufferTestStep

  1516 	{

  1517 public:

  1518 	TAudioInputFillBuffer3TestStep(MDataSource* aSource, CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1519 	: TAudioInputFillBufferTestStep(aSource, aBuffer, aSink)

  1520 	{ }

  1522 	TVerdict DoTestStepL();

  1523 	};

  1525 class TAudioInputFillBuffer4TestStep : public TAudioInputFillBufferTestStep

  1526 	{

  1527 public:

  1528 	TAudioInputFillBuffer4TestStep(CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1529 	: TAudioInputFillBufferTestStep(NULL, aBuffer, aSink)

  1530 	{ }

  1532 	TVerdict DoTestStepL();

  1533 	};

  1535 class TAudioInputFillBuffer5TestStep : public TAudioInputFillBufferTestStep

  1536 	{

  1537 public:

  1538 	TAudioInputFillBuffer5TestStep(CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1539 	: TAudioInputFillBufferTestStep(NULL, aBuffer, aSink)

  1540 	{ }

  1542 	TVerdict DoTestStepL();

  1543 	};

  1545 class TAudioInputFillBuffer6TestStep : public TAudioInputFillBufferTestStep

  1546 	{

  1547 public:

  1548 	TAudioInputFillBuffer6TestStep(CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1549 	: TAudioInputFillBufferTestStep(NULL, aBuffer, aSink)

  1550 	{ }

  1552 	TVerdict DoTestStepL();

  1553 	};

  1555 class TAudioInputFillBuffer7TestStep : public TAudioInputFillBufferTestStep

  1556 	{

  1557 public:

  1558 	TAudioInputFillBuffer7TestStep(CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1559 	: TAudioInputFillBufferTestStep(NULL, aBuffer, aSink)

  1560 	{ }

  1562 	TVerdict DoTestStepL();

  1563 	};

  1565 class TAudioInputFillBuffer8TestStep : public TAudioInputFillBufferTestStep

  1566 	{

  1567 public:

  1568 	TAudioInputFillBuffer8TestStep(CMMFBuffer* aBuffer, CMMFDummySink* aSink)

  1569 	: TAudioInputFillBufferTestStep(NULL, aBuffer, aSink)

  1570 	{ }

  1572 	TVerdict DoTestStepL();

  1573 	};

  1576 class TAudioOutputEmptyBufferTestStep : public TTestStep

  1577 	{

  1578 public:

  1579 	TAudioOutputEmptyBufferTestStep(MDataSink* aSink, CMMFBuffer* aBuffer, CMMFDummySource* aSource)

  1580 	: TTestStep(aSource, aSink), iBuffer(aBuffer), iAsynchronousWrite(EFalse)

  1581 	{ }

  1583 	void SetAsynchronousWrite()

  1584 	{ iAsynchronousWrite = ETrue; }

  1586 	TVerdict DoTestStepL();

  1588 public:

  1589 	CMMFBuffer* iBuffer;

  1590 	TBool iAsynchronousWrite;

  1591 	};

  1593 class TAudioOutputEmptyBuffer2TestStep : public TAudioOutputEmptyBufferTestStep

  1594 	{

  1595 public:

  1596 	TAudioOutputEmptyBuffer2TestStep(MDataSink* aSink, CMMFBuffer* aBuffer, CMMFDummySource* aSource)

  1597 	: TAudioOutputEmptyBufferTestStep(aSink, aBuffer, aSource)

  1598 	{ iAsynchronousWrite = ETrue; }

  1600 	TVerdict DoTestStepL();

  1601 	};

  1603 class TAudioOutputEmptyBuffer3TestStep : public TAudioOutputEmptyBufferTestStep

  1604 	{

  1605 public:

  1606 	TAudioOutputEmptyBuffer3TestStep(MDataSink* aSink, CMMFBuffer* aBuffer, CMMFDummySource* aSource)

  1607 	: TAudioOutputEmptyBufferTestStep(aSink, aBuffer, aSource)

  1608 	{ iAsynchronousWrite = ETrue; }

  1610 	TVerdict DoTestStepL();

  1611 	};

  1613 class TAudioOutputEmptyBuffer4TestStep : public TAudioOutputEmptyBufferTestStep

  1614 	{

  1615 public:

  1616 	TAudioOutputEmptyBuffer4TestStep(CMMFBuffer* aBuffer, CMMFDummySource* aSource, MDataSource& aRealFormat)

  1617 	: TAudioOutputEmptyBufferTestStep(NULL, aBuffer, aSource), iRealFormat(aRealFormat)

  1618 	{ }

  1620 	TVerdict DoTestStepL();

  1622 public:

  1623 	MDataSource& iRealFormat;

  1624 	};

  1626 class TAudioOutputEmptyBuffer5TestStep : public TAudioOutputEmptyBufferTestStep

  1627 	{

  1628 public:

  1629 	TAudioOutputEmptyBuffer5TestStep(CMMFBuffer* aBuffer, CMMFDummySource* aSource, MDataSource& aRealFormat)

  1630 	: TAudioOutputEmptyBufferTestStep(NULL, aBuffer, aSource), iRealFormat(aRealFormat)

  1631 	{ }

  1633 	TVerdict DoTestStepL();

  1635 public:

  1636 	MDataSource& iRealFormat;

  1637 	};

  1639 class TAudioOutputEmptyBuffer6TestStep : public TAudioOutputEmptyBufferTestStep

  1640 	{

  1641 public:

  1642 	TAudioOutputEmptyBuffer6TestStep(CMMFBuffer* aBuffer, CMMFDummySource* aSource, MDataSource& aRealFormat)

  1643 	: TAudioOutputEmptyBufferTestStep(NULL, aBuffer, aSource), iRealFormat(aRealFormat)

  1644 	{ }

  1646 	TVerdict DoTestStepL();

  1648 public:

  1649 	MDataSource& iRealFormat;

  1650 	};

  1652 class TPrimeStopTestStep : public TFileTestStep

  1653 	{

  1654 public:

  1655 	TPrimeStopTestStep()

  1656 		{ }

  1658 	virtual TVerdict DoTestStepL();

  1659 	};

  1662 class TPrimeStopSinkTestStep : public TFileTestStep

  1663 	{

  1664 public:

  1665 	TPrimeStopSinkTestStep()

  1666 		{ }

  1668 	virtual TVerdict DoTestStepL();

  1669 	};

  1672 /**

  1673  *

  1674  * CTestStep_MMF_SRSSNK, which is the base class for all

  1675  * the SelfTest suite test steps.

  1676  *

  1677  * @lib "TSU_MMF_SRSSNK.lib"

  1678  *

  1679  * @xxxx

  1680  *

  1681  */

  1682 const TInt KErrFileFail = -12345;

  1683 class CTestStep_MMF_SRSSNK : public CTestStep

  1684 	{

  1685 public:

  1686 	CTestStep_MMF_SRSSNK(TBool aIsAllocTest = ETrue);

  1687 	~CTestStep_MMF_SRSSNK();

  1688 	static void CleanUp(TAny *aPtr);

  1689 	inline void SetTestSuite(const CTestSuite_MMF_SRSSNK* aTestSuite);

  1691 	void DoTestStep(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount = 0);

  1692 	void DoTestStepWithAllocFail(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount = 0);

  1693 	void DoTestStepWithFileFail(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount = 0);

  1694 	void DoTestStepWithAllocAndFileFail(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult);

  1696 	void DoTest(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount = 0);

  1697 	void DoFileTest(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult);

  1698 	void DoFileTestWithoutAllocFail(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount);

  1700 	// from CTestStep

  1701 public:

  1702 	TVerdict OpenL();

  1704 protected:

  1705 	void CopyFileL(RFs& aFs, const TDesC& aOld, const TDesC& aNew);

  1707 	void OpenFileL(const TDesC& aFileName, TInt aMode, TBool aShareProtected=EFalse);

  1708 	void CloseFile();

  1710 	void DeleteFileSinkL(TSinkType aSinkType, RFs& aFs, TDesC& aFileName);

  1713 protected:

  1714 	// pointer to suite which owns this test

  1715 	const CTestSuite_MMF_SRSSNK* iMMFBaseClTestSuite;

  1717 	TVerdict iTestResult;

  1718 	TBool iIsAllocTest;

  1719 	TBool iFileFailureTestingEnabled;

  1720 	RFile iFile;

  1721 	RFs iFs;

  1722 	};

  1724 inline void CTestStep_MMF_SRSSNK::SetTestSuite(const CTestSuite_MMF_SRSSNK* aTestSuite)

  1725 	{

  1726 	iMMFBaseClTestSuite = aTestSuite;

  1727 	}

  1729 /**

  1730  *

  1731  *

  1732  */

  1733 class CTestStep_MMF_SRSSNK_U_0001 : public CTestStep_MMF_SRSSNK

  1734 	{

  1735 public:

  1736 	CTestStep_MMF_SRSSNK_U_0001();

  1737 	~CTestStep_MMF_SRSSNK_U_0001();

  1738 	virtual TVerdict DoTestStepL();

  1739 	};

  1742 /**

  1743  *

  1744  *

  1745  */

  1746 class CTestStep_MMF_SRSSNK_U_0002 : public CTestStep_MMF_SRSSNK

  1747 	{

  1748 public:

  1749 	CTestStep_MMF_SRSSNK_U_0002();

  1750 	~CTestStep_MMF_SRSSNK_U_0002();

  1751 	virtual TVerdict DoTestStepL();

  1752 	};

  1754 /**

  1755  *

  1756  *

  1757  */

  1758 class CTestStep_MMF_SRSSNK_U_0003 : public CTestStep_MMF_SRSSNK

  1759 	{

  1760 public:

  1761 	CTestStep_MMF_SRSSNK_U_0003();

  1762 	~CTestStep_MMF_SRSSNK_U_0003();

  1763 	virtual TVerdict DoTestStepL();

  1764 	};

  1767 /**

  1768  *

  1769  *

  1770  */

  1771 class CTestStep_MMF_SRSSNK_U_0004 : public CTestStep_MMF_SRSSNK

  1772 	{

  1773 public:

  1774 	CTestStep_MMF_SRSSNK_U_0004();

  1775 	~CTestStep_MMF_SRSSNK_U_0004();

  1776 	virtual TVerdict DoTestStepL();

  1777 	};

  1780 /**

  1781  *

  1782  *

  1783  */

  1784 class CTestStep_MMF_SRSSNK_U_0005 : public CTestStep_MMF_SRSSNK

  1785 	{

  1786 public:

  1787 	CTestStep_MMF_SRSSNK_U_0005();

  1788 	~CTestStep_MMF_SRSSNK_U_0005();

  1789 	virtual TVerdict DoTestStepL();

  1790 	};

  1793 /**

  1794  *

  1795  *

  1796  */

  1797 class CTestStep_MMF_SRSSNK_U_0006 : public CTestStep_MMF_SRSSNK

  1798 	{

  1799 public:

  1800 	CTestStep_MMF_SRSSNK_U_0006();

  1801 	~CTestStep_MMF_SRSSNK_U_0006();

  1802 	virtual TVerdict DoTestStepL();

  1803 	};

  1806 /**

  1807  *

  1808  *

  1809  */

  1810 class CTestStep_MMF_SRSSNK_U_0007 : public CTestStep_MMF_SRSSNK

  1811 	{

  1812 public:

  1813 	CTestStep_MMF_SRSSNK_U_0007();

  1814 	~CTestStep_MMF_SRSSNK_U_0007();

  1815 	virtual TVerdict DoTestStepL();

  1816 	};

  1819 /**

  1820  *

  1821  *

  1822  */

  1823 class CTestStep_MMF_SRSSNK_U_0008 : public CTestStep_MMF_SRSSNK

  1824 	{

  1825 public:

  1826 	CTestStep_MMF_SRSSNK_U_0008();

  1827 	~CTestStep_MMF_SRSSNK_U_0008();

  1828 	virtual TVerdict DoTestStepL();

  1829 	};

  1832 /**

  1833  *

  1834  *

  1835  */

  1836 class CTestStep_MMF_SRSSNK_U_0009 : public CTestStep_MMF_SRSSNK

  1837 	{

  1838 public:

  1839 	CTestStep_MMF_SRSSNK_U_0009();

  1840 	~CTestStep_MMF_SRSSNK_U_0009();

  1841 	virtual TVerdict DoTestStepL();

  1842 	};

  1845 /**

  1846  *

  1847  *

  1848  */

  1849 class CTestStep_MMF_SRSSNK_U_0010 : public CTestStep_MMF_SRSSNK

  1850 	{

  1851 public:

  1852 	CTestStep_MMF_SRSSNK_U_0010();

  1853 	~CTestStep_MMF_SRSSNK_U_0010();

  1854 	virtual TVerdict DoTestStepL();

  1855 	};

  1857 /**

  1858  *

  1859  *

  1860  */

  1861 class CTestStep_MMF_SRSSNK_U_0011 : public CTestStep_MMF_SRSSNK

  1862 	{

  1863 public:

  1864 	CTestStep_MMF_SRSSNK_U_0011();

  1865 	~CTestStep_MMF_SRSSNK_U_0011();

  1866 	virtual TVerdict DoTestStepL();

  1867 	};

  1869 /**

  1870  *

  1871  *

  1872  */

  1873 class CTestStep_MMF_SRSSNK_U_0012 : public CTestStep_MMF_SRSSNK

  1874 	{

  1875 public:

  1876 	CTestStep_MMF_SRSSNK_U_0012();

  1877 	~CTestStep_MMF_SRSSNK_U_0012();

  1878 	virtual TVerdict DoTestStepL();

  1879 	};

  1881 /**

  1882  *

  1883  *

  1884  */

  1885 class CTestStep_MMF_SRSSNK_U_0013 : public CTestStep_MMF_SRSSNK

  1886 	{

  1887 public:

  1888 	CTestStep_MMF_SRSSNK_U_0013();

  1889 	~CTestStep_MMF_SRSSNK_U_0013();

  1890 	virtual TVerdict DoTestStepL();

  1891 	};

  1893 /**

  1894  *

  1895  *

  1896  */

  1897 class CTestStep_MMF_SRSSNK_U_0014 : public CTestStep_MMF_SRSSNK

  1898 	{

  1899 public:

  1900 	CTestStep_MMF_SRSSNK_U_0014();

  1901 	~CTestStep_MMF_SRSSNK_U_0014();

  1902 	virtual TVerdict DoTestStepL();

  1903 	};

  1905 /**

  1906  *

  1907  *

  1908  */

  1909 class CTestStep_MMF_SRSSNK_U_0015 : public CTestStep_MMF_SRSSNK

  1910 	{

  1911 public:

  1912 	CTestStep_MMF_SRSSNK_U_0015();

  1913 	~CTestStep_MMF_SRSSNK_U_0015();

  1914 	virtual TVerdict DoTestStepL();

  1915 	};

  1918 /**

  1919  *

  1920  *

  1921  */

  1922 class CTestStep_MMF_SRSSNK_U_0101 : public CTestStep_MMF_SRSSNK

  1923 	{

  1924 public:

  1925 	CTestStep_MMF_SRSSNK_U_0101();

  1926 	~CTestStep_MMF_SRSSNK_U_0101();

  1927 	virtual TVerdict DoTestStepL();

  1928 	};

  1930 /**

  1931  *

  1932  *

  1933  */

  1934 class CTestStep_MMF_SRSSNK_U_0102 : public CTestStep_MMF_SRSSNK

  1935 	{

  1936 public:

  1937 	CTestStep_MMF_SRSSNK_U_0102();

  1938 	~CTestStep_MMF_SRSSNK_U_0102();

  1939 	virtual TVerdict DoTestStepL();

  1940 	};

  1943 /**

  1944  *

  1945  *

  1946  */

  1947 class CTestStep_MMF_SRSSNK_U_0103 : public CTestStep_MMF_SRSSNK

  1948 	{

  1949 public:

  1950 	CTestStep_MMF_SRSSNK_U_0103();

  1951 	~CTestStep_MMF_SRSSNK_U_0103();

  1952 	virtual TVerdict DoTestStepL();

  1953 	};

  1956 /**

  1957  *

  1958  *

  1959  */

  1960 class CTestStep_MMF_SRSSNK_U_0104 : public CTestStep_MMF_SRSSNK

  1961 	{

  1962 public:

  1963 	CTestStep_MMF_SRSSNK_U_0104();

  1964 	~CTestStep_MMF_SRSSNK_U_0104();

  1965 	virtual TVerdict DoTestStepL();

  1966 	};

  1970 /**

  1971  *

  1972  *

  1973  */

  1974 class CTestStep_MMF_SRSSNK_FileSourceMisc : public CTestStep_MMF_SRSSNK

  1975 	{

  1976 public:

  1977 	CTestStep_MMF_SRSSNK_FileSourceMisc(TSourceType aSourceType);

  1978 	~CTestStep_MMF_SRSSNK_FileSourceMisc();

  1979 	virtual TVerdict DoTestStepL();

  1980 private:

  1981 	TSourceType iSourceType;

  1982 	};

  1985 /**

  1986  *

  1987  *

  1988  */

  1989 class CTestStep_MMF_SRSSNK_FileFillBuffer : public CTestStep_MMF_SRSSNK

  1990 	{

  1991 public:

  1992 	CTestStep_MMF_SRSSNK_FileFillBuffer(TSourceType aSourceType);

  1993 	~CTestStep_MMF_SRSSNK_FileFillBuffer();

  1994 	virtual TVerdict DoTestStepL();

  1995 private:

  1996 	TSourceType iSourceType;

  1997 	};

  2002 /**

  2003  *

  2004  *

  2005  */

  2006 class CTestStep_MMF_SRSSNK_U_0107 : public CTestStep_MMF_SRSSNK

  2007 	{

  2008 public:

  2009 	CTestStep_MMF_SRSSNK_U_0107();

  2010 	~CTestStep_MMF_SRSSNK_U_0107();

  2011 	virtual TVerdict DoTestStepL();

  2012 	};

  2015 /**

  2016  *

  2017  *

  2018  */

  2019 class CTestStep_MMF_SRSSNK_FileReadBuffer : public CTestStep_MMF_SRSSNK

  2020 	{

  2021 public:

  2022 	CTestStep_MMF_SRSSNK_FileReadBuffer(TSourceType aSourceType);

  2023 	~CTestStep_MMF_SRSSNK_FileReadBuffer();

  2024 	virtual TVerdict DoTestStepL();

  2025 private:

  2026 	TSourceType iSourceType;

  2027 	};

  2030 /**

  2031  *

  2032  *

  2033  */

  2034 class CTestStep_MMF_SRSSNK_U_0109 : public CTestStep_MMF_SRSSNK

  2035 	{

  2036 public:

  2037 	CTestStep_MMF_SRSSNK_U_0109();

  2038 	~CTestStep_MMF_SRSSNK_U_0109();

  2039 	virtual TVerdict DoTestStepL();

  2040 	};

  2043 /**

  2044  *

  2045  *

  2046  */

  2047 class CTestStep_MMF_SRSSNK_FileSinkMisc : public CTestStep_MMF_SRSSNK

  2048 	{

  2049 public:

  2050 	CTestStep_MMF_SRSSNK_FileSinkMisc(TSinkType aSinkType);

  2051 	~CTestStep_MMF_SRSSNK_FileSinkMisc();

  2052 	virtual TVerdict DoTestStepL();

  2053 private:

  2054 	TSinkType iSinkType;

  2055 	};

  2058 /**

  2059  *

  2060  *

  2061  */

  2062 class CTestStep_MMF_SRSSNK_FileEmptyBuffer : public CTestStep_MMF_SRSSNK

  2063 	{

  2064 public:

  2065 	CTestStep_MMF_SRSSNK_FileEmptyBuffer(TSinkType aSinkType);

  2066 	~CTestStep_MMF_SRSSNK_FileEmptyBuffer();

  2067 	virtual TVerdict DoTestStepL();

  2069 private:

  2070 	TSinkType iSinkType;

  2071 	};

  2074 /**

  2075  *

  2076  *

  2077  */

  2078 class CTestStep_MMF_SRSSNK_U_0112 : public CTestStep_MMF_SRSSNK

  2079 	{

  2080 public:

  2081 	CTestStep_MMF_SRSSNK_U_0112();

  2082 	~CTestStep_MMF_SRSSNK_U_0112();

  2083 	virtual TVerdict DoTestStepL();

  2084 	};

  2087 /**

  2088  *

  2089  *

  2090  */

  2091 class CTestStep_MMF_SRSSNK_FileWriteBuffer : public CTestStep_MMF_SRSSNK

  2092 	{

  2093 public:

  2094 	CTestStep_MMF_SRSSNK_FileWriteBuffer(TSinkType aSinkType);

  2095 	~CTestStep_MMF_SRSSNK_FileWriteBuffer();

  2096 	virtual TVerdict DoTestStepL();

  2098 private:

  2099 	TSinkType iSinkType;

  2100 	};

  2103 /**

  2104  *

  2105  *

  2106  */

  2107 class CTestStep_MMF_SRSSNK_U_0114 : public CTestStep_MMF_SRSSNK

  2108 	{

  2109 public:

  2110 	CTestStep_MMF_SRSSNK_U_0114();

  2111 	~CTestStep_MMF_SRSSNK_U_0114();

  2112 	virtual TVerdict DoTestStepL();

  2113 	};

  2115 /**

  2116  *

  2117  *

  2118  */

  2119 class CTestStep_MMF_SRSSNK_U_0115 : public CTestStep_MMF_SRSSNK

  2120 	{

  2121 public:

  2122 	CTestStep_MMF_SRSSNK_U_0115();

  2123 	~CTestStep_MMF_SRSSNK_U_0115();

  2124 	virtual TVerdict DoTestStepL();

  2125 	};

  2128 /**

  2129  *

  2130  *

  2131  */

  2132 class CTestStep_MMF_SRSSNK_FileEvaluateIntent : public CTestStep_MMF_SRSSNK

  2133 	{

  2134 public:

  2135 	CTestStep_MMF_SRSSNK_FileEvaluateIntent(TSourceType aSourceType);

  2136 	~CTestStep_MMF_SRSSNK_FileEvaluateIntent();

  2137 	virtual TVerdict DoTestStepL();

  2138 private:

  2139 	TSourceType iSourceType;

  2140 	TSinkType iSinkType;

  2141 	};

  2143 /**

  2144  *

  2145  *

  2146  */

  2147 class CTestStep_MMF_SRSSNK_FileExecuteIntent : public CTestStep_MMF_SRSSNK

  2148 	{

  2149 public:

  2150 	CTestStep_MMF_SRSSNK_FileExecuteIntent(TSourceType aSourceType);

  2151 	~CTestStep_MMF_SRSSNK_FileExecuteIntent();

  2152 	virtual TVerdict DoTestStepL();

  2153 private:

  2154 	TSourceType iSourceType;

  2155 	TSinkType iSinkType;

  2156 	};

  2159 /*

  2160  *

  2161  *

  2162  */

  2163 class CTestStep_MMF_SRSSNK_FileIsProtected : public CTestStep_MMF_SRSSNK

  2164 	{

  2165 public:

  2166 	CTestStep_MMF_SRSSNK_FileIsProtected(TSourceType aSourceType);

  2167 	~CTestStep_MMF_SRSSNK_FileIsProtected();

  2168 	virtual TVerdict DoTestStepL();

  2169 private:

  2170 	TSourceType iSourceType;

  2171 	TSinkType iSinkType;

  2172 	};

  2174 /*

  2175  *

  2176  *

  2177  */

  2178 class CTestStep_MMF_SRSSNK_U_0119 : public CTestStep_MMF_SRSSNK

  2179 	{

  2180 public:

  2181 	CTestStep_MMF_SRSSNK_U_0119();

  2182 	~CTestStep_MMF_SRSSNK_U_0119();

  2183 	virtual TVerdict DoTestStepL();

  2184 	};

  2187 /**

  2188  *

  2189  *

  2190  */

  2191 class CTestStep_MMF_SRSSNK_U_0201 : public CTestStep_MMF_SRSSNK

  2192 	{

  2193 public:

  2194 	CTestStep_MMF_SRSSNK_U_0201();

  2195 	~CTestStep_MMF_SRSSNK_U_0201();

  2196 	virtual TVerdict DoTestStepL();

  2197 	};

  2200 /**

  2201  *

  2202  *

  2203  */

  2204 class CTestStep_MMF_SRSSNK_U_0202 : public CTestStep_MMF_SRSSNK

  2205 	{

  2206 public:

  2207 	CTestStep_MMF_SRSSNK_U_0202();

  2208 	~CTestStep_MMF_SRSSNK_U_0202();

  2209 	virtual TVerdict DoTestStepL();

  2210 	};

  2213 /**

  2214  *

  2215  *

  2216  */

  2217 class CTestStep_MMF_SRSSNK_U_0203 : public CTestStep_MMF_SRSSNK

  2218 	{

  2219 public:

  2220 	CTestStep_MMF_SRSSNK_U_0203();

  2221 	~CTestStep_MMF_SRSSNK_U_0203();

  2222 	virtual TVerdict DoTestStepL();

  2223 	};

  2225 /**

  2226  *

  2227  *

  2228  */

  2229 class CTestStep_MMF_SRSSNK_U_0204 : public CTestStep_MMF_SRSSNK

  2230 	{

  2231 public:

  2232 	CTestStep_MMF_SRSSNK_U_0204();

  2233 	~CTestStep_MMF_SRSSNK_U_0204();

  2234 	virtual TVerdict DoTestStepL();

  2235 	};

  2237 /**

  2238  *

  2239  *

  2240  */

  2241 class CTestStep_MMF_SRSSNK_U_0205 : public CTestStep_MMF_SRSSNK

  2242 	{

  2243 public:

  2244 	CTestStep_MMF_SRSSNK_U_0205();

  2245 	~CTestStep_MMF_SRSSNK_U_0205();

  2246 	virtual TVerdict DoTestStepL();

  2247 	};

  2249 /**

  2250  *

  2251  *

  2252  */

  2253 class CTestStep_MMF_SRSSNK_U_0206 : public CTestStep_MMF_SRSSNK

  2254 	{

  2255 public:

  2256 	CTestStep_MMF_SRSSNK_U_0206();

  2257 	~CTestStep_MMF_SRSSNK_U_0206();

  2258 	virtual TVerdict DoTestStepL();

  2259 	};

  2261 /**

  2262  *

  2263  *

  2264  */

  2265 class CTestStep_MMF_SRSSNK_U_0207 : public CTestStep_MMF_SRSSNK, public MDevSoundObserver

  2266 	{

  2267 public:

  2268 	CTestStep_MMF_SRSSNK_U_0207();

  2269 	~CTestStep_MMF_SRSSNK_U_0207();

  2270 	virtual TVerdict DoTestStepL();

  2272 	// from MDevSoundObserver

  2273 	virtual void InitializeComplete(TInt aError);

  2274 	virtual void ToneFinished(TInt /*aError*/) {};

  2275 	virtual void BufferToBeFilled(CMMFBuffer* /*aBuffer*/) {};

  2276 	virtual void PlayError(TInt /*aError*/) {};

  2277 	virtual void BufferToBeEmptied(CMMFBuffer* /*aBuffer*/) {};

  2278 	virtual void RecordError(TInt /*aError*/) {};

  2279 	virtual void ConvertError(TInt /*aError*/) {};

  2280 	virtual void DeviceMessage(TUid /*aMessageType*/, const TDesC8& /*aMsg*/) {};

  2281 	virtual void SendEventToClient(const TMMFEvent& /*aEvent*/) {};

  2282 	CMMFAudioInput* iSource; // not owned by CTestStep_MMF_SRSSNK_U_0207, but transient

  2283 	TInt iError;

  2284 	};

  2286 /**

  2287  *

  2288  *

  2289  */

  2290 class CTestStep_MMF_SRSSNK_U_0208 : public CTestStep_MMF_SRSSNK

  2291 	{

  2292 public:

  2293 	CTestStep_MMF_SRSSNK_U_0208();

  2294 	~CTestStep_MMF_SRSSNK_U_0208();

  2295 	virtual TVerdict DoTestStepL();

  2296 	};

  2298 /**

  2299  *

  2300  *

  2301  */

  2302 class CTestStep_MMF_SRSSNK_U_0209 : public CTestStep_MMF_SRSSNK

  2303 	{

  2304 public:

  2305 	CTestStep_MMF_SRSSNK_U_0209();

  2306 	~CTestStep_MMF_SRSSNK_U_0209();

  2307 	virtual TVerdict DoTestStepL();

  2308 	};

  2310 /**

  2311  *

  2312  *

  2313  */

  2314 class CTestStep_MMF_SRSSNK_U_0210 : public CTestStep_MMF_SRSSNK

  2315 	{

  2316 public:

  2317 	CTestStep_MMF_SRSSNK_U_0210();

  2318 	~CTestStep_MMF_SRSSNK_U_0210();

  2319 	virtual TVerdict DoTestStepL();

  2320 	};

  2322 /**

  2323  *

  2324  *

  2325  */

  2326 class CTestStep_MMF_SRSSNK_U_0211 : public CTestStep_MMF_SRSSNK

  2327 	{

  2328 public:

  2329 	CTestStep_MMF_SRSSNK_U_0211();

  2330 	~CTestStep_MMF_SRSSNK_U_0211();

  2331 	virtual TVerdict DoTestStepL();

  2332 	};

  2334 /**

  2335  *

  2336  *

  2337  */

  2338 class CTestStep_MMF_SRSSNK_U_0212 : public CTestStep_MMF_SRSSNK

  2339 	{

  2340 public:

  2341 	CTestStep_MMF_SRSSNK_U_0212();

  2342 	~CTestStep_MMF_SRSSNK_U_0212();

  2343 	virtual TVerdict DoTestStepL();

  2344 	};

  2346 /*

  2347  *

  2348  *

  2349  */

  2350 class CTestStep_MMF_SRSSNK_U_0301 : public CTestStep_MMF_SRSSNK

  2351 	{

  2352 public:

  2353 	CTestStep_MMF_SRSSNK_U_0301();

  2354 	~CTestStep_MMF_SRSSNK_U_0301();

  2355 	virtual TVerdict DoTestStepL();

  2356 	};

  2358 /*

  2359  *

  2360  *

  2361  */

  2362 class CTestStep_MMF_SRSSNK_U_0302 : public CTestStep_MMF_SRSSNK

  2363 	{

  2364 public:

  2365 	CTestStep_MMF_SRSSNK_U_0302();

  2366 	~CTestStep_MMF_SRSSNK_U_0302();

  2367 	virtual TVerdict DoTestStepL();

  2368 	};

  2371 /*  Testing of the Source and Sink

  2372  *

  2373  *

  2374  */

  2376 class CTestStep_MMF_SRSSNK_U_0400 : public CTestStep_MMF_SRSSNK

  2377 	{

  2378 public:

  2379 	CTestStep_MMF_SRSSNK_U_0400();

  2380 	~CTestStep_MMF_SRSSNK_U_0400();

  2381 	virtual TVerdict DoTestStepL();

  2382 	};

  2384 class CTestStep_MMF_SRSSNK_U_0405 : public CTestStep_MMF_SRSSNK

  2385 	{

  2386 public:

  2387 	CTestStep_MMF_SRSSNK_U_0405();

  2388 	~CTestStep_MMF_SRSSNK_U_0405();

  2389 	virtual TVerdict DoTestStepL();

  2390 	};

  2392 class CTestStep_MMF_SRSSNK_U_0406 : public CTestStep_MMF_SRSSNK

  2393 	{

  2394 public:

  2395 	CTestStep_MMF_SRSSNK_U_0406();

  2396 	~CTestStep_MMF_SRSSNK_U_0406();

  2397 	virtual TVerdict DoTestStepL();

  2398 	};

  2400 class CTestStep_MMF_SRSSNK_U_0407 : public CTestStep_MMF_SRSSNK

  2401 	{

  2402 public:

  2403 	CTestStep_MMF_SRSSNK_U_0407();

  2404 	~CTestStep_MMF_SRSSNK_U_0407();

  2405 	virtual TVerdict DoTestStepL();

  2406 	};

  2408 class CTestStep_MMF_SRSSNK_U_0408 : public CTestStep_MMF_SRSSNK

  2409 	{

  2410 public:

  2411 	CTestStep_MMF_SRSSNK_U_0408();

  2412 	~CTestStep_MMF_SRSSNK_U_0408();

  2413 	virtual TVerdict DoTestStepL();

  2414 	};

  2417 class CTestStep_MMF_SRSSNK_U_0409 : public CTestStep_MMF_SRSSNK

  2418 	{

  2419 public:

  2420 	CTestStep_MMF_SRSSNK_U_0409();

  2421 	~CTestStep_MMF_SRSSNK_U_0409();

  2422 	virtual TVerdict DoTestStepL();

  2423 	};

  2425 class CTestStep_MMF_SRSSNK_U_0410 : public CTestStep_MMF_SRSSNK

  2426 	{

  2427 public:

  2428 	CTestStep_MMF_SRSSNK_U_0410();

  2429 	~CTestStep_MMF_SRSSNK_U_0410();

  2430 	virtual TVerdict DoTestStepL();

  2431 	};

  2433 class CTestStep_MMF_SRSSNK_U_0411 : public CTestStep_MMF_SRSSNK

  2434 	{

  2435 public:

  2436 	CTestStep_MMF_SRSSNK_U_0411();

  2437 	~CTestStep_MMF_SRSSNK_U_0411();

  2438 	virtual TVerdict DoTestStepL();

  2439 	};

  2441 class CTestStep_MMF_SRSSNK_U_0412 : public CTestStep_MMF_SRSSNK

  2442 	{

  2443 public:

  2444 	CTestStep_MMF_SRSSNK_U_0412();

  2445 	~CTestStep_MMF_SRSSNK_U_0412();

  2446 	virtual TVerdict DoTestStepL();

  2447 	};

  2449 class CTestStep_MMF_SRSSNK_U_0413 : public CTestStep_MMF_SRSSNK

  2450 	{

  2451 public:

  2452 	CTestStep_MMF_SRSSNK_U_0413();

  2453 	~CTestStep_MMF_SRSSNK_U_0413();

  2454 	virtual TVerdict DoTestStepL();

  2455 	};

  2457 class CTestStep_MMF_SRSSNK_U_0414 : public CTestStep_MMF_SRSSNK

  2458 	{

  2459 public:

  2460 	CTestStep_MMF_SRSSNK_U_0414();

  2461 	~CTestStep_MMF_SRSSNK_U_0414();

  2462 	virtual TVerdict DoTestStepL();

  2463 	};

  2465 class CTestStep_MMF_SRSSNK_U_0415 : public CTestStep_MMF_SRSSNK

  2466 	{

  2467 public:

  2468 	CTestStep_MMF_SRSSNK_U_0415();

  2469 	~CTestStep_MMF_SRSSNK_U_0415();

  2470 	virtual TVerdict DoTestStepL();

  2471 	};

  2473 class CTestStep_MMF_SRSSNK_U_0416 : public CTestStep_MMF_SRSSNK

  2474 	{

  2475 public:

  2476 	CTestStep_MMF_SRSSNK_U_0416();

  2477 	~CTestStep_MMF_SRSSNK_U_0416();

  2478 	virtual TVerdict DoTestStepL();

  2479 	};

  2481 class CTestStep_MMF_SRSSNK_U_0417 : public CTestStep_MMF_SRSSNK

  2482 	{

  2483 public:

  2484 	CTestStep_MMF_SRSSNK_U_0417();

  2485 	~CTestStep_MMF_SRSSNK_U_0417();

  2486 	virtual TVerdict DoTestStepL();

  2487 	};

  2489 class CTestStep_MMF_SRSSNK_U_0418 : public CTestStep_MMF_SRSSNK

  2490 	{

  2491 public:

  2492 	CTestStep_MMF_SRSSNK_U_0418();

  2493 	~CTestStep_MMF_SRSSNK_U_0418();

  2494 	virtual TVerdict DoTestStepL();

  2495 	};

  2497 class CTestStep_MMF_SRSSNK_U_0419 : public CTestStep_MMF_SRSSNK

  2498 	{

  2499 public:

  2500 	CTestStep_MMF_SRSSNK_U_0419();

  2501 	~CTestStep_MMF_SRSSNK_U_0419();

  2502 	virtual TVerdict DoTestStepL();

  2503 	};

  2505 class CTestStep_MMF_SRSSNK_U_0420 : public CTestStep_MMF_SRSSNK

  2506 	{

  2507 public:

  2508 	CTestStep_MMF_SRSSNK_U_0420();

  2509 	~CTestStep_MMF_SRSSNK_U_0420();

  2510 	virtual TVerdict DoTestStepL();

  2511 	};

  2513 class CTestStep_MMF_SRSSNK_U_0421 : public CTestStep_MMF_SRSSNK

  2514 	{

  2515 public:

  2516 	CTestStep_MMF_SRSSNK_U_0421();

  2517 	~CTestStep_MMF_SRSSNK_U_0421();

  2518 	virtual TVerdict DoTestStepL();

  2519 	};

  2521 /*

  2522  *

  2523  *  Sinks

  2524  *

  2525  */

  2527 class CTestStep_MMF_SRSSNK_U_0500 : public CTestStep_MMF_SRSSNK

  2528 	{

  2529 public:

  2530 	CTestStep_MMF_SRSSNK_U_0500();

  2531 	~CTestStep_MMF_SRSSNK_U_0500();

  2532 	virtual TVerdict DoTestStepL();

  2533 	};

  2535 class CTestStep_MMF_SRSSNK_U_0505 : public CTestStep_MMF_SRSSNK

  2536 	{

  2537 public:

  2538 	CTestStep_MMF_SRSSNK_U_0505();

  2539 	~CTestStep_MMF_SRSSNK_U_0505();

  2540 	virtual TVerdict DoTestStepL();

  2541 	};

  2543 class CTestStep_MMF_SRSSNK_U_0506 : public CTestStep_MMF_SRSSNK

  2544 	{

  2545 public:

  2546 	CTestStep_MMF_SRSSNK_U_0506();

  2547 	~CTestStep_MMF_SRSSNK_U_0506();

  2548 	virtual TVerdict DoTestStepL();

  2549 	};

  2552 class CTestStep_MMF_SRSSNK_U_0507 : public CTestStep_MMF_SRSSNK

  2553 	{

  2554 public:

  2555 	CTestStep_MMF_SRSSNK_U_0507();

  2556 	~CTestStep_MMF_SRSSNK_U_0507();

  2557 	virtual TVerdict DoTestStepL();

  2558 	};

  2561 class CTestStep_MMF_SRSSNK_U_0508 : public CTestStep_MMF_SRSSNK

  2562 	{

  2563 public:

  2564 	CTestStep_MMF_SRSSNK_U_0508();

  2565 	~CTestStep_MMF_SRSSNK_U_0508();

  2566 	virtual TVerdict DoTestStepL();

  2567 	};

  2569 class CTestStep_MMF_SRSSNK_U_0509 : public CTestStep_MMF_SRSSNK

  2570 	{

  2571 public:

  2572 	CTestStep_MMF_SRSSNK_U_0509();

  2573 	~CTestStep_MMF_SRSSNK_U_0509();

  2574 	virtual TVerdict DoTestStepL();

  2575 	};

  2579 class CTestStep_MMF_SRSSNK_U_0510 : public CTestStep_MMF_SRSSNK

  2580 	{

  2581 public:

  2582 	CTestStep_MMF_SRSSNK_U_0510();

  2583 	~CTestStep_MMF_SRSSNK_U_0510();

  2584 	virtual TVerdict DoTestStepL();

  2585 	};

  2589 class CTestStep_MMF_SRSSNK_U_0511 : public CTestStep_MMF_SRSSNK

  2590 	{

  2591 public:

  2592 	CTestStep_MMF_SRSSNK_U_0511();

  2593 	~CTestStep_MMF_SRSSNK_U_0511();

  2594 	virtual TVerdict DoTestStepL();

  2595 	};

  2598 class CTestStep_MMF_SRSSNK_U_0512 : public CTestStep_MMF_SRSSNK

  2599 	{

  2600 public:

  2601 	CTestStep_MMF_SRSSNK_U_0512();

  2602 	~CTestStep_MMF_SRSSNK_U_0512();

  2603 	virtual TVerdict DoTestStepL();

  2604 	};

  2607 class CTestStep_MMF_SRSSNK_U_0513 : public CTestStep_MMF_SRSSNK

  2608 	{

  2609 public:

  2610 	CTestStep_MMF_SRSSNK_U_0513();

  2611 	~CTestStep_MMF_SRSSNK_U_0513();

  2612 	virtual TVerdict DoTestStepL();

  2613 	};

  2617 class CTestStep_MMF_SRSSNK_U_0514 : public CTestStep_MMF_SRSSNK

  2618 	{

  2619 public:

  2620 	CTestStep_MMF_SRSSNK_U_0514();

  2621 	~CTestStep_MMF_SRSSNK_U_0514();

  2622 	virtual TVerdict DoTestStepL();

  2623 	};

  2626 class CTestStep_MMF_SRSSNK_U_0515 : public CTestStep_MMF_SRSSNK

  2627 	{

  2628 public:

  2629 	CTestStep_MMF_SRSSNK_U_0515();

  2630 	~CTestStep_MMF_SRSSNK_U_0515();

  2631 	virtual TVerdict DoTestStepL();

  2632 	};

  2635 class CTestStep_MMF_SRSSNK_U_0516 : public CTestStep_MMF_SRSSNK

  2636 	{

  2637 public:

  2638 	CTestStep_MMF_SRSSNK_U_0516();

  2639 	~CTestStep_MMF_SRSSNK_U_0516();

  2640 	virtual TVerdict DoTestStepL();

  2641 	};

  2644 class CTestStep_MMF_SRSSNK_U_0517 : public CTestStep_MMF_SRSSNK

  2645 	{

  2646 public:

  2647 	CTestStep_MMF_SRSSNK_U_0517();

  2648 	~CTestStep_MMF_SRSSNK_U_0517();

  2649 	virtual TVerdict DoTestStepL();

  2650 	};

  2654 class CTestStep_MMF_SRSSNK_U_0518 : public CTestStep_MMF_SRSSNK

  2655 	{

  2656 public:

  2657 	CTestStep_MMF_SRSSNK_U_0518();

  2658 	~CTestStep_MMF_SRSSNK_U_0518();

  2659 	virtual TVerdict DoTestStepL();

  2660 	};

  2664 class CTestStep_MMF_SRSSNK_U_0519 : public CTestStep_MMF_SRSSNK

  2665 	{

  2666 public:

  2667 	CTestStep_MMF_SRSSNK_U_0519();

  2668 	~CTestStep_MMF_SRSSNK_U_0519();

  2669 	virtual TVerdict DoTestStepL();

  2670 	};

  2673 class CTestStep_MMF_SRSSNK_MultipleStop : public CTestStep_MMF_SRSSNK

  2674 	{

  2675 public:

  2676 	CTestStep_MMF_SRSSNK_MultipleStop(); // U_520

  2677 	~CTestStep_MMF_SRSSNK_MultipleStop();

  2678 	virtual TVerdict DoTestStepL();

  2679 private:

  2680 	TSourceType iSourceType;

  2681 	};

  2683 // INC085391: CMMFFile::iFilePath and iFileDrive should be initialised for KMMFileHandleSource

  2684 class CTestStep_MMF_SRSSNK_U_0600 : public CTestStep_MMF_SRSSNK

  2685 	{

  2686 public:

  2687 	CTestStep_MMF_SRSSNK_U_0600();

  2688 	~CTestStep_MMF_SRSSNK_U_0600();

  2689 	virtual TVerdict DoTestStepL();

  2690 	};

  2692 //CR0854 - Provide access to the file data via the CData object

  2693 class CTestStep_MMF_SRSSNK_U_0521 : public CTestStep_MMF_SRSSNK

  2694 	{

  2695 public:

  2696 	CTestStep_MMF_SRSSNK_U_0521();

  2697 	~CTestStep_MMF_SRSSNK_U_0521();

  2698 	virtual TVerdict DoTestStepL();

  2699 	};

  2701 //CR0854 - Provide access to the file data via the CData object

  2702 class CTestStep_MMF_SRSSNK_U_0522 : public CTestStep_MMF_SRSSNK

  2703 	{

  2704 public:

  2705 	CTestStep_MMF_SRSSNK_U_0522();

  2706 	~CTestStep_MMF_SRSSNK_U_0522();

  2707 	virtual TVerdict DoTestStepL();

  2708 	};

  2710 // PDEF102849: Invalid Remaining Space value obtained for E:\ (memory card)

  2711 class CTestStep_MMF_SRSSNK_U_0523 : public CTestStep_MMF_SRSSNK

  2712 	{

  2713 public:

  2714 	CTestStep_MMF_SRSSNK_U_0523();

  2715 	~CTestStep_MMF_SRSSNK_U_0523();

  2716 	virtual TVerdict DoTestStepL();

  2717 	};

  2719 //PDEF137282 - Answering VoIP call doesn't work

  2720 class CTestStep_MMF_SRSSNK_U_0524 : public CTestStep_MMF_SRSSNK

  2721 	{

  2722 public:

  2723 	CTestStep_MMF_SRSSNK_U_0524();

  2724 	~CTestStep_MMF_SRSSNK_U_0524();

  2725 	virtual TVerdict DoTestStepL();

  2726 	};

  2728 class TCreateSourceBuffer3TestStep : public TTestStep, public MAsyncEventHandler

  2729 	{

  2730 public:

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

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

  2733 	{ }

  2735 	TVerdict DoTestStepL();

  2736 	TInt SendEventToClient(const TMMFEvent& aEvent);

  2738 public:

  2739 	TSourceType iSourceType;

  2740 	CMMFBuffer* iSinkBuffer;

  2741 	TUid iExpectedType;

  2742 	TBool iExpectedRef;

  2743 	TInt iExpectedMaxLength;

  2744 	};

  2746 #endif /* __TSU_MMF_SRSSNK_H__ */

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--