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 // The test specification for these tests can be found in:

    15 // V:\Dev\GT\GT 0137 Multimedia Codec - Msrvr\Testing\Unit Test Specifications\

    16 // Typhoon\SGL.GT0137.134 Rev1.00 MMF SRSSNK Unit Test Specification.xls

    17 // Changes made to the test harness as a result of the DevSound WP AudioInput/Output

    18 // modifications have been marked with DevSound WP Change along with an explanation

    19 // of why the code changed

    20 // Main changes caused by:

    21 // 7.0s test seemed to assume the Prime could come after the thread logon

    22 // this assumption is invalid, but happened to work on the 7.0s audio I/O as

    23 // the prime did very little

    24 // assumed Prime does very little including no memory allocation

    25 // assmued that once the active scheduler started no further memory

    26 // was allocated and hence no callbacks if an OOM condition occured during play

    27 // assumed test could drive Empty/FillBufferL calls and could own and set

    28 // buffers - in 8.0s buffers are ultimately owned by HwDevice not test app

    29 // so cannot make multiple calls to Empty/FillBuffer

    30 // assumed audio output could only accept pcm16 - not true on 8.0

    31 //

    32 //

    34 // EPOC includes

    35 #include <e32base.h>

    36 #include <caf/caf.h>

    38 using namespace ContentAccess;

    40 // Test system includes

    41 #include "TSU_MMF_SRSSNK.h"

    42 #include "TSU_MMF_SRSSNKSuite.h"

    44  //INC085391

    45 #include "mmfclientutility.h"

    47 // __REQUIREDFORDEBUG macro gets rid of warnings in release builds

    48 #if defined(_DEBUG)

    49 #define __REQUIREDFORDEBUG(X) X

    50 #else

    51 #define __REQUIREDFORDEBUG(X)

    52 #endif

    54 const TInt KStartFileFailAt = 8;	// start at zero when RFile::Duplicate() problem is fixed

    56 _LIT8(KEmptyFourCCCode, "    ");

    58 _LIT(KTest101FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile1.dat");

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

    61 	{

    62 	ASSERT(aSourceType == ESourceTypeFile || aSourceType == ESourceTypeFileHandle);

    64 	MDataSource* source;

    66 	if (aSourceType == ESourceTypeFile)

    67 		{

    68 		TMMFFileConfig configFile;

    69 		configFile().iPath = aFileName;

    70 		source = MDataSource::NewSourceL(KUidMmfFileSource, configFile);

    71 		}

    72 	else

    73 		{

    74 		User::LeaveIfError(aFs.ShareProtected());

    75 		TMMFFileHandleConfig configFile;

    76 		RFile file;

    77 		User::LeaveIfError(file.Open(aFs, aFileName, EFileRead|EFileShareReadersOnly));

    78 		CleanupClosePushL(file);

    79 		configFile().iFile = &file;

    80 		source = MDataSource::NewSourceL(KUidMmfFileSource, configFile);

    81 		CleanupStack::PopAndDestroy(&file);

    83 		}

    84 	return source;

    85 	}

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

    88 	{

    89 	User::LeaveIfError(aFs.ShareProtected());

    90 	RFile file;

    91 	User::LeaveIfError(file.Open(aFs, aFileName, EFileRead|EFileShareReadersOnly));

    92 	CleanupClosePushL(file);

    93 	CMMFileSourceSink* fileSourceSink = CMMFileSourceSink::NewLC(KMMFileHandleSourceUid, file);

    94 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, fileSourceSink->SourceSinkData());

    95 	CleanupStack::PopAndDestroy(2, &file); //fileSourceSink

    97 	return source;

    98 	}

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

   101 	{

   102 	MDataSink* sink;

   104 	if (aSinkType == ESinkTypeFile)

   105 		{

   106 		TMMFFileConfig configFile;

   107 		configFile().iPath = aFileName;

   108 		sink = MDataSink::NewSinkL(KUidMmfFileSink, configFile);

   109 		}

   110 	else

   111 		{

   112 		User::LeaveIfError(aFs.ShareProtected());

   113 		RFile file;

   114 		TMMFFileHandleConfig fileConfig(&file);

   115 		TInt err = file.Open(aFs, aFileName, EFileWrite|EFileRead|EFileShareAny);

   116 		if (err == KErrNotFound)

   117 			{

   118 			User::LeaveIfError(file.Create(aFs, aFileName, EFileWrite|EFileRead|EFileShareAny));

   119 			}

   120 		else

   121 			{

   122 			User::LeaveIfError(err);

   123 			}

   124 		CleanupClosePushL(file);

   125 		sink = MDataSink::NewSinkL(KUidMmfFileSink, fileConfig);

   126 		CleanupStack::PopAndDestroy(&file);

   128 		}

   129 	return sink;

   130 	}

   134 void TTestStep::DoTestPreambleL()

   135 	{

   136 	}

   138 TVerdict TTestStep::DoTestPostambleL(TBool /*aCheck*/)

   139 	{

   140 	return EPass;

   141 	}

   143 TVerdict TTestStep::DoNegativeTestPostambleL()

   144 	{

   145 	return DoTestPostambleL(EFalse);

   146 	}

   148 MDataSource* TTestStep::CreateSourceL(TSourceType aSourceType, HBufC8* aDes)

   149 	{

   150 	MDataSource* source = NULL;

   151 	switch(aSourceType)

   152 		{

   153 		case ESourceTypeDes:

   154 			{

   155 			TPtr8 dataPtr(aDes->Des());

   156 			// Initialise config data.

   157 			TMMFDescriptorConfig configDes;

   158 			configDes().iDes = &dataPtr;

   159 			configDes().iDesThreadId = RThread().Id();

   160 			source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

   161 			}

   162 			break;

   163 		case ESourceTypeFile:

   164 			{

   165 			// Initialise config data.

   166 			TMMFFileConfig configDes;

   167 			configDes().iPath = KTest101FileName;

   168 			source = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

   169 			}

   170 			break;

   172 		case ESourceTypeFileHandle:

   173 			{

   174 			TMMFFileHandleConfig fileConfig;

   175 			RFs fs;

   176 			User::LeaveIfError(fs.Connect());

   177 			CleanupClosePushL(fs);

   178 			RFile file;

   179 			User::LeaveIfError(file.Open(fs, KTest101FileName, EFileRead|EFileShareReadersOnly));

   180 			CleanupClosePushL(file);

   181 			fileConfig().iFile = &file;

   182 			source = MDataSource::NewSourceL(KUidMmfFileSource, fileConfig);

   183 			CleanupStack::PopAndDestroy(2, &fs);

   184 			}

   185 			break;

   187 		case ESourceTypeAudio:

   188 			{

   189 			TBuf8<1> configDes;

   190 			source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

   192 			//DevSound WP - needs resetting as of OOM occurs buffer may not be filled ok

   193 			static_cast<CMMFDummySink*>(iSink)->ResetBufferFilledOk();

   194 			}

   195 			break;

   196 		default:

   197 			User::Leave(KErrGeneral);

   198 		}

   199 	return source;

   200 	}

   203 void TReadBufferTestStep::RandomiseBuffer()

   204 	{

   205 	if ((iBuffer->Type() == KUidMmfTransferBuffer) ||

   206 	(iBuffer->Type() == KUidMmfDescriptorBuffer))

   207 		{

   208 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

   210 		// Re-randomise data buffer.

   211 		TDes8& dataDes = buffer->Data();

   212 		TUint8* dataPtr = CONST_CAST(TUint8*, dataDes.Ptr());

   213 		TInt bufferMaxLength = dataDes.MaxLength();

   214 		for (TInt i = 0 ; i<bufferMaxLength ; i++)

   215 			dataPtr[i] = TUint8(Math::Rand(iSeed));

   217 		dataDes.SetLength(bufferMaxLength);

   218 		}

   219 	}

   221 TInt TReadBufferTestStep::CheckBuffer()

   222 	{

   223 	TInt readLength = iBuffer->BufferSize();

   224 	CMMFDescriptorBuffer* buffer = STATIC_CAST(CMMFDescriptorBuffer*, iBuffer);

   226 	const TUint8* sourcePtr = iSourceDes.Ptr();

   227 	return Mem::Compare(sourcePtr+iPosition, readLength, buffer->Data().Ptr(), readLength);

   228 	}

   231 void TWriteBufferTestStep::RandomiseBuffer()

   232 	{

   233 	if ((iBuffer->Type() == KUidMmfTransferBuffer) ||

   234 	(iBuffer->Type() == KUidMmfDescriptorBuffer))

   235 		{

   236 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

   238 		// Re-randomise data buffer.

   239 		TDes8& dataDes = buffer->Data();

   240 		TUint8* dataPtr = CONST_CAST(TUint8*, dataDes.Ptr());

   241 		TInt bufferMaxLength = dataDes.MaxLength();

   242 		for (TInt i = 0 ; i<bufferMaxLength ; i++)

   243 			dataPtr[i] = TUint8(Math::Rand(iSeed));

   244 		}

   245 	}

   247 TInt TWriteBufferToDescriptorTestStep::CheckDestinationL()

   248 	{

   249 	TInt length = iDestinationDes.Length();

   250 	if (length != iCopyOfDestinationDes.Length())

   251 		return -1;

   253 	return Mem::Compare(iDestinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

   254 	}

   256 TInt TWriteBufferToFileTestStep::CheckDestinationL()

   257 	{

   258 	TInt length = iCopyOfDestinationDes.Length();

   260 	// Read the file into a descriptor.

   261 	RFile destinationFile;

   262 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead|EFileShareAny);

   263 	CleanupClosePushL(destinationFile);

   264 	if (err != KErrNone)

   265 		{

   266 		CleanupStack::PopAndDestroy(&destinationFile);

   268 		if (err == KErrNotFound)

   269 			return (length != 0) ? -1 : 0;

   271 		User::Leave(err);

   272 		}

   274 	TInt destinationFileSize;

   275 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

   277 	// Check that the file length is correct.

   278 	if (destinationFileSize != length)

   279 		{

   280 		CleanupStack::PopAndDestroy(&destinationFile);

   281 		return -1;

   282 		}

   284 	HBufC8* destinationHBuf = HBufC8::NewLC(length);

   285 	TPtr8 destinationDes = destinationHBuf->Des();

   286 	User::LeaveIfError(destinationFile.Read(destinationDes));

   288 	// Check that the file data matches.

   289 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

   290 	CleanupStack::PopAndDestroy(destinationHBuf);

   291 	CleanupStack::PopAndDestroy(&destinationFile);

   293 	return err;

   294 	}

   296 void TWriteBufferToFileTestStep::DoTestPreambleL()

   297 	{

   298 	if (iSink != NULL)

   299 		iSink->SinkPrimeL();

   300 	}

   302 //

   303 // Tests that use ECom to create sources/sinks should call

   304 // REcomSession::FinalClose in the PostambleL.

   305 //

   306 TVerdict TFileTestStep::DoTestPostambleL(TBool /*aCheck*/)

   307 	{

   308 	REComSession::FinalClose();

   309 	return EPass;

   310 	}

   312 // TNewSourceTestStep

   313 // Attempt to create a new data source, using the supplied Uid and config data.

   314 // Delete the source after creation (test for memory leak in construction)

   315 TVerdict TNewSourceTestStep::DoTestStepL()

   316 	{

   317 	MDataSource* source = MDataSource::NewSourceL(iUid, *iConfigDes);

   319 	delete source;

   320 	return EPass;

   321 	}

   323 // TSourceTypeTestStep

   324 // Check that the data source type and data type codes are initialised correctly.

   325 TVerdict TSourceTypeTestStep::DoTestStepL()

   326 	{

   327 	TUid dataSourceType = iSource->DataSourceType();

   328 	if (dataSourceType != iUid)

   329 		return EFail;

   331 	TMediaId mediaId;

   332 	TFourCC fourCC = iSource->SourceDataTypeCode(mediaId);

   333 	if (fourCC != iFourCC)

   334 		return EFail;

   336 	fourCC = 0x4E554C4C; // 'LLUN'

   337 	TInt err = iSource->SetSourceDataTypeCode(fourCC, mediaId);

   338 	if (iCanSetSourceDataType)

   339 		{

   340 		if (err != KErrNone)

   341 			User::Leave(err);

   343 		if (iSource->SourceDataTypeCode(mediaId) != fourCC)

   344 			return EFail;

   346 		User::LeaveIfError(iSource->SetSourceDataTypeCode(iFourCC, mediaId));

   347 		}

   348 	else

   349 		{

   350 		if (err != KErrNotSupported)

   351 			{

   352 			if (err == KErrNone)

   353 				return EFail;

   355 			User::Leave(err);

   356 			}

   358 		if (iSource->SourceDataTypeCode(mediaId) != iFourCC)

   359 			return EFail;

   360 		}

   362 	return EPass;

   363 	}

   365 // TCanCreateSourceBufferTestStep

   366 // Test that MDataSource::CanCreateSourceBuffer returns the expected value. (either ETrue or EFalse)

   367 TVerdict TCanCreateSourceBufferTestStep::DoTestStepL()

   368 	{

   369 	return (iSource->CanCreateSourceBuffer() == iCanCreateSourceBuffer) ? EPass : EFail;

   370 	}

   372 // TSourceSampleConvertTestStep

   373 // Test that MDataSource::SourceSampleConvert returns the expected value. (either ETrue or EFalse)

   374 TVerdict TSourceSampleConvertTestStep::DoTestStepL()

   375 	{

   376 	return (iSource->SourceSampleConvert() == iSourceSampleConvert) ? EPass : EFail;

   377 	}

   379 TInt TCreateSourceBuffer1TestStep::SendEventToClient(const TMMFEvent& aEvent)

   380 	{

   381 	// This callback won't get called for this test

   382 	//	DevSoundWP - yes it will

   383 	if (aEvent.iErrorCode == KErrNoMemory)

   384 		CActiveScheduler::Stop();

   385 //	ASSERT(aEvent.iErrorCode == KErrNone);

   386 	return 0;

   387 	}

   390 TVerdict TCreateSourceBuffer1TestStep::DoTestStepL()

   391 	{

   392 	TMediaId mediaId;

   393 	TBool ref;

   394 	MDataSource* source = NULL;

   395 	HBufC8* dataDes = NULL;

   398 	if (iSourceType == ESourceTypeDes)

   399 		{

   400 		dataDes = HBufC8::NewLC(KTestDataSize);

   401 		}

   403 	source = CreateSourceL(iSourceType, dataDes);

   404 	CleanupDeletePushL(source);

   406 	CMMFBuffer* nullBuffer = source->CreateSourceBufferL(mediaId, ref);

   408 	TInt err = source->SourceThreadLogon(*this);

   409 	User::LeaveIfError(err);

   410 	TBool loggedOn = ETrue;

   412 	source->NegotiateSourceL(*iSink);

   414 	//DevSound WP - Must Prime before calling FillBufferL

   415 	source->SourcePrimeL();

   417 	//DevSound WP - Audio Input effectively drives flow in v8.0

   418 	//so just make first call to FillBufferL and then call active scheduler

   419 	source->FillBufferL(nullBuffer, iSink, mediaId);	// first call inits DevSound

   420 	//source->FillBufferL(nullBuffer, iSink, mediaId);	// second call starts recording

   422 	CActiveScheduler::Start();	// wait for BufferFilledL callback

   424 	CMMFBuffer* buffer = static_cast<CMMFDummySink*>(iSink)->MmfBuffer();

   426 	TVerdict result = EPass;

   427 	if ((buffer) && (static_cast<CMMFDummySink*>(iSink)->BufferFilledOk()))

   428 		{

   429 		if (ref != iExpectedRef)

   430 			result = EFail;

   432 		if (buffer->Type() != iExpectedType)

   433 			result = EFail;

   436 		//	if (buffer->Status() != EAvailable)

   437 		//	result = EFail;

   442 		buffer = NULL;

   444 		//DevSound WP done this	source->SourcePrimeL();

   445 		source->SourcePlayL();

   446 		source->SourcePauseL();

   447 		source->SourceStopL();

   448 		}

   451 	TMMFPrioritySettings prioritySettings;

   452 	source->SetSourcePrioritySettings(prioritySettings);

   453 	if (loggedOn)

   454 		source->SourceThreadLogoff();

   456 //	if (buffer != NULL) DevSound WP  it's not your buffer to delete

   457 //		result = EFail;		// buffer not deleted

   459 	CleanupStack::PopAndDestroy(source);

   460 	if (dataDes)

   461 		CleanupStack::PopAndDestroy(dataDes);

   463 	return result;

   464 	}

   466 TInt TCreateSourceBuffer2TestStep::SendEventToClient(const TMMFEvent& aEvent)

   467 	{

   468 	// This callback won't get called for this test

   469 	//DevSound WP - this callback can get called as an OOM condition can occur

   470 	//on the alloc tests after the active scheduler has started

   471 	//ASSERT(aEvent.iErrorCode == KErrNone);

   472 	//	DevSoundWP - if it is OOM need to stop active scheduler

   473 	if (aEvent.iErrorCode == KErrNoMemory)

   474 		CActiveScheduler::Stop();

   475 	return 0;

   476 	}

   478 TVerdict TCreateSourceBuffer2TestStep::DoTestStepL()

   479 	{

   480 	TMediaId mediaId;

   481 	TBool ref;

   482 	MDataSource* source = NULL;

   483 	HBufC8* dataDes = NULL;

   485 	if (iSourceType == ESourceTypeDes)

   486 		{

   487 		dataDes = HBufC8::NewLC(KTestDataSize);

   488 		}

   490 	source = CreateSourceL(iSourceType, dataDes);

   491 	CleanupDeletePushL(source);

   493 	CMMFBuffer* nullBuffer = source->CreateSourceBufferL(mediaId, *iSinkBuffer, ref);

   495 	TInt err = source->SourceThreadLogon(*this);

   496 	User::LeaveIfError(err);

   497 	TBool loggedOn = ETrue;

   499 	source->NegotiateSourceL(*iSink);

   501 	//DevSound WP - Must Prime before calling FillBufferL

   502 	source->SourcePrimeL();

   504 	//DevSound WP - Audio Input effectively drives flow in v8.0

   505 	//so just make first call to FillBufferL and then call active scheduler

   506 	source->FillBufferL(nullBuffer, iSink, mediaId);	// first call inits DevSound

   507 	//source->FillBufferL(nullBuffer, iSink, mediaId);	// second call starts recording

   509 	CActiveScheduler::Start();	// wait for BufferFilledL callback

   511 	CMMFBuffer* buffer = static_cast<CMMFDummySink*>(iSink)->MmfBuffer();

   513 	TVerdict result = EPass;

   514 	//DevSound WP	if (buffer)

   515 	//an OOM can occur during AS in which case buffer is not valid

   516 	if ((buffer) && (static_cast<CMMFDummySink*>(iSink)->BufferFilledOk()))

   517 		{

   518 		if (ref != iExpectedRef)

   519 			result = EFail;

   521 		if (buffer->Type() != iExpectedType)

   522 			result = EFail;

   525 		buffer = NULL;

   527 		source->SourcePlayL();

   528 		source->SourcePauseL();

   529 		source->SourceStopL();

   530 		}

   532 	TMMFPrioritySettings prioritySettings;

   533 	source->SetSourcePrioritySettings(prioritySettings);

   534 	if (loggedOn)

   535 		source->SourceThreadLogoff();

   537 //DevSound WP buffer not null if OOM

   538 	//if (buffer != NULL)

   539 	//result = EFail;		// buffer not deleted

   541 	CleanupStack::PopAndDestroy(source);

   542 	if (dataDes)

   543 		CleanupStack::PopAndDestroy(dataDes);

   545 	return result;

   546 	}

   548 TVerdict TSourceThreadLogonTestStep::DoTestStepL()

   549 	{

   550 	User::LeaveIfError(iSource->SourceThreadLogon(*iEventHandler));

   552 	iSource->SourceThreadLogoff();

   554 	return EPass;

   555 	}

   557 TVerdict TNegotiateSourceTestStep::DoTestStepL()

   558 	{

   559 	iSource->NegotiateSourceL(*iSink);

   560 	return EPass;

   561 	}

   563 TVerdict TFillBufferTestStep::DoTestStepL()

   564 	{

   565 	RandomiseBuffer();

   567 	TMediaId mediaId;

   568 	TRAPD(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

   569 	if (iAsynchronousRead && (err == KErrNone))

   570 		CActiveScheduler::Start();

   572 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

   573 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

   574 	if ((err != KErrNone) && sinkBufferFilledOk)

   575 		return EFail;

   577 	if (err != KErrNone)

   578 		User::Leave(err);

   580 	if (!sinkBufferFilledOk)

   581 		{

   582 		if ((err = dummySink->Error()) != KErrNone)

   583 			User::Leave(err);

   585 		return EFail;

   586 		}

   588 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

   589 	TInt readLength = buffer->BufferSize();

   590 	if (readLength != iReadLength)

   591 		return EFail;

   593 	err = CheckBuffer();

   594 	iPosition += readLength;

   595 	return (err == 0) ? EPass : EFail;

   596 	}

   598 TVerdict TFillLastBufferTestStep::DoTestStepL()

   599 	{

   600 	// Create big buffer.

   601 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

   602 	CleanupStack::PushL(bigBuffer);

   604 	// Create valid buffer.

   605 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

   606 	CleanupStack::PushL(validBuffer);

   608 	// Randomise the valid buffer.

   609 	iBuffer = validBuffer;

   610 	RandomiseBuffer();

   612 	// Create a descriptor source.

   613 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

   614 	MDataSource* source = MDataSource::NewSourceL(iSourceUid, iConfigDes);

   615 	CleanupDeletePushL(source);

   616 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

   617 	source->SourcePrimeL();

   619 	iPosition = 0;

   620 	TMediaId mediaId;

   621 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

   622 	if (iAsynchronousRead && (err == KErrNone))

   623 		CActiveScheduler::Start();

   625 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

   626 	if ((err != KErrNone) && sinkBufferFilledOk)

   627 		{

   628 		CleanupStack::PopAndDestroy(source);

   629 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   630 		return EFail;

   631 		}

   633 	if (err != KErrNone)

   634 		{

   635 		CleanupStack::PopAndDestroy(source);

   636 		User::Leave(err);

   637 		}

   639 	if (!sinkBufferFilledOk)

   640 		{

   641 		CleanupStack::PopAndDestroy(source);

   643 		if ((err = dummySink->Error()) != KErrNone)

   644 			User::Leave(err);

   646 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   647 		return EFail;

   648 		}

   650 	if (iBuffer->LastBuffer())

   651 		{

   652 		CleanupStack::PopAndDestroy(source);

   654 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   655 		return EFail;

   656 		}

   658 	err = CheckBuffer();

   659 	if (err)

   660 		{

   661 		CleanupStack::PopAndDestroy(source);

   663 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   664 		return EFail;

   665 		}

   667 	// Randomise the big buffer.

   668 	iBuffer = bigBuffer;

   669 	RandomiseBuffer();

   671 	TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

   672 	if (iAsynchronousRead && (err == KErrNone))

   673 		CActiveScheduler::Start();

   675 	sinkBufferFilledOk = dummySink->BufferFilledOk();

   676 	if ((err != KErrNone) && sinkBufferFilledOk)

   677 		{

   678 		CleanupStack::PopAndDestroy(source);

   680 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   681 		return EFail;

   682 		}

   684 	if (err != KErrNone)

   685 		{

   686 		CleanupStack::PopAndDestroy(source);

   688 		User::Leave(err);

   689 		}

   691 	if (!sinkBufferFilledOk)

   692 		{

   693 		CleanupStack::PopAndDestroy(source);

   695 		if ((err = dummySink->Error()) != KErrNone)

   696 			User::Leave(err);

   698 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   699 		return EFail;

   700 		}

   702 	if (!iBuffer->LastBuffer())

   703 		{

   704 		CleanupStack::PopAndDestroy(source);

   706 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   707 		return EFail;

   708 		}

   710 	iPosition += KTestBufferSize;

   711 	err = CheckBuffer();

   712 	if (err)

   713 		{

   714 		CleanupStack::PopAndDestroy(source);

   716 		CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   717 		return EFail;

   718 		}

   720 	CleanupStack::PopAndDestroy(source);

   722 	// Test last buffer with request size.

   723 	source = STATIC_CAST(CMMFClip*, MDataSource::NewSourceL(iSourceUid, iConfigDes));

   724 	CleanupDeletePushL(source);

   725 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

   726 	source->SourcePrimeL();

   728 	TBool lastBuffer;

   729 	validBuffer->SetRequestSizeL(KTestReadSize);

   731 	iPosition = 0;

   732 	iBuffer = validBuffer;

   733 	do

   734 		{

   735 		RandomiseBuffer();

   736 		TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

   737 		if (iAsynchronousRead && (err == KErrNone))

   738 			CActiveScheduler::Start();

   740 		sinkBufferFilledOk = dummySink->BufferFilledOk();

   741 		if ((err != KErrNone) && sinkBufferFilledOk)

   742 			{

   743 			CleanupStack::PopAndDestroy(source);

   745 			CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   746 			return EFail;

   747 			}

   749 		if (err != KErrNone)

   750 			{

   751 			CleanupStack::PopAndDestroy(source);

   753 			User::Leave(err);

   754 			}

   756 		if (!sinkBufferFilledOk)

   757 			{

   758 			CleanupStack::PopAndDestroy(source);

   760 			if ((err = dummySink->Error()) != KErrNone)

   761 				User::Leave(err);

   763 			CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   764 			return EFail;

   765 			}

   767 		lastBuffer = (KTestDataSize-iPosition)<KTestReadSize;

   768 		if (iBuffer->LastBuffer() != lastBuffer)

   769 			{

   770 			CleanupStack::PopAndDestroy(source);

   772 			CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   773 			return EFail;

   774 			}

   776 		err = CheckBuffer();

   777 		if (err)

   778 			{

   779 			CleanupStack::PopAndDestroy(source);

   781 			CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   782 			return EFail;

   783 			}

   785 		iPosition+= validBuffer->BufferSize();

   786 		}

   787 	while (validBuffer->BufferSize() != 0);

   789 	CleanupStack::PopAndDestroy(source);

   791 	CleanupStack::PopAndDestroy(2, bigBuffer); // validBuffer, bigBuffer

   792 	return EPass;

   793 	}

   795 TVerdict TReadLastBufferTestStep::DoTestStepL()

   796 	{

   797 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

   799 	// Create valid buffer.

   800 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

   801 	CleanupStack::PushL(validBuffer);

   803 	// Randomise the valid buffer.

   804 	iBuffer = validBuffer;

   805 	RandomiseBuffer();

   807 	// Test last buffer without request size.

   808 	iPosition = 0;

   809 	TRAPD(err, clip->ReadBufferL(KTestBufferSize, iBuffer, iPosition, iSink));

   810 	if (iAsynchronousRead && (err == KErrNone))

   811 		CActiveScheduler::Start();

   813 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

   814 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

   815 	if ((err != KErrNone) && sinkBufferFilledOk)

   816 		{

   817 		CleanupStack::PopAndDestroy(validBuffer);

   818 		return EFail;

   819 		}

   821 	if (err != KErrNone)

   822 		User::Leave(err);

   824 	if (!sinkBufferFilledOk)

   825 		{

   826 		if ((err = dummySink->Error()) != KErrNone)

   827 			User::Leave(err);

   829 		CleanupStack::PopAndDestroy(validBuffer);

   830 		return EFail;

   831 		}

   833 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() < TUint(KTestBufferSize)))

   834 		{

   835 		CleanupStack::PopAndDestroy(validBuffer);

   836 		return EFail;

   837 		}

   839 	err = CheckBuffer();

   840 	if (err)

   841 		{

   842 		CleanupStack::PopAndDestroy(validBuffer);

   843 		return EFail;

   844 		}

   846 	iPosition = KTestDataSize-10;

   847 	TRAP(err, clip->ReadBufferL(KTestReadSize, iBuffer, iPosition, iSink));

   848 	if (iAsynchronousRead && (err == KErrNone))

   849 		CActiveScheduler::Start();

   851 	sinkBufferFilledOk = dummySink->BufferFilledOk();

   852 	if ((err != KErrNone) && sinkBufferFilledOk)

   853 		{

   854 		CleanupStack::PopAndDestroy(validBuffer);

   855 		return EFail;

   856 		}

   858 	if (err != KErrNone)

   859 		User::Leave(err);

   861 	if (!sinkBufferFilledOk)

   862 		{

   863 		if ((err = dummySink->Error()) != KErrNone)

   864 			User::Leave(err);

   866 		CleanupStack::PopAndDestroy(validBuffer);

   867 		return EFail;

   868 		}

   870 	if (!validBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

   871 		{

   872 		CleanupStack::PopAndDestroy(validBuffer);

   873 		return EFail;

   874 		}

   876 	err = CheckBuffer();

   877 	if (err)

   878 		{

   879 		CleanupStack::PopAndDestroy(validBuffer);

   880 		return EFail;

   881 		}

   882 	CleanupStack::PopAndDestroy(validBuffer);

   884 	validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

   885 	CleanupStack::PushL(validBuffer);

   887 	// Randomise the valid buffer.

   888 	iBuffer = validBuffer;

   889 	RandomiseBuffer();

   891 	// Test last buffer with request size.

   892 	validBuffer->SetRequestSizeL(KTestReadSize);

   894 	iPosition = 0;

   895 	TRAP(err, clip->ReadBufferL(KTestReadSize, iBuffer, iPosition, iSink));

   896 	if (iAsynchronousRead && (err == KErrNone))

   897 		CActiveScheduler::Start();

   899 	sinkBufferFilledOk = dummySink->BufferFilledOk();

   900 	if ((err != KErrNone) && sinkBufferFilledOk)

   901 		{

   902 		CleanupStack::PopAndDestroy(validBuffer);

   903 		return EFail;

   904 		}

   906 	if (err != KErrNone)

   907 		User::Leave(err);

   909 	if (!sinkBufferFilledOk)

   910 		{

   911 		if ((err = dummySink->Error()) != KErrNone)

   912 			User::Leave(err);

   914 		CleanupStack::PopAndDestroy(validBuffer);

   915 		return EFail;

   916 		}

   918 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() < TUint(KTestReadSize)))

   919 		{

   920 		CleanupStack::PopAndDestroy(validBuffer);

   921 		return EFail;

   922 		}

   924 	err = CheckBuffer();

   925 	if (err)

   926 		{

   927 		CleanupStack::PopAndDestroy(validBuffer);

   928 		return EFail;

   929 		}

   931 	iPosition = KTestDataSize - 10;

   932 	TRAP(err, clip->ReadBufferL(KTestReadSize, iBuffer, iPosition, iSink));

   933 	if (iAsynchronousRead && (err == KErrNone))

   934 		CActiveScheduler::Start();

   936 	sinkBufferFilledOk = dummySink->BufferFilledOk();

   937 	if ((err != KErrNone) && sinkBufferFilledOk)

   938 		{

   939 		CleanupStack::PopAndDestroy(validBuffer);

   940 		return EFail;

   941 		}

   943 	if (err != KErrNone)

   944 		User::Leave(err);

   946 	if (!sinkBufferFilledOk)

   947 		{

   948 		if ((err = dummySink->Error()) != KErrNone)

   949 			User::Leave(err);

   951 		CleanupStack::PopAndDestroy(validBuffer);

   952 		return EFail;

   953 		}

   955 	if (!iBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

   956 		{

   957 		CleanupStack::PopAndDestroy(validBuffer);

   958 		return EFail;

   959 		}

   961 	err = CheckBuffer();

   962 	if (err)

   963 		{

   964 		CleanupStack::PopAndDestroy(validBuffer);

   965 		return EFail;

   966 		}

   968 	CleanupStack::PopAndDestroy(validBuffer);

   969 	return EPass;

   970 	}

   972 TVerdict TReadLastBuffer2TestStep::DoTestStepL()

   973 	{

   974 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

   976 	// Create valid buffer.

   977 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

   978 	CleanupStack::PushL(validBuffer);

   980 	// Randomise the valid buffer.

   981 	iBuffer = validBuffer;

   982 	RandomiseBuffer();

   984 	// Test last buffer without request size.

   985 	iPosition = 0;

   986 	TRAPD(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

   987 	if (iAsynchronousRead && (err == KErrNone))

   988 		CActiveScheduler::Start();

   990 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

   991 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

   992 	if ((err != KErrNone) && sinkBufferFilledOk)

   993 		{

   994 		CleanupStack::PopAndDestroy(validBuffer);

   995 		return EFail;

   996 		}

   998 	if (err != KErrNone)

   999 		User::Leave(err);

  1001 	if (!sinkBufferFilledOk)

  1002 		{

  1003 		if ((err = dummySink->Error()) != KErrNone)

  1004 			User::Leave(err);

  1006 		CleanupStack::PopAndDestroy(validBuffer);

  1007 		return EFail;

  1008 		}

  1010 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() != TUint(KTestBufferSize)))

  1011 		{

  1012 		CleanupStack::PopAndDestroy(validBuffer);

  1013 		return EFail;

  1014 		}

  1016 	err = CheckBuffer();

  1017 	if (err)

  1018 		{

  1019 		CleanupStack::PopAndDestroy(validBuffer);

  1020 		return EFail;

  1021 		}

  1023 	iPosition = KTestDataSize-10;

  1024 	TRAP(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

  1025 	if (iAsynchronousRead && (err == KErrNone))

  1026 		CActiveScheduler::Start();

  1028 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  1029 	if ((err != KErrNone) && sinkBufferFilledOk)

  1030 		{

  1031 		CleanupStack::PopAndDestroy(validBuffer);

  1032 		return EFail;

  1033 		}

  1035 	if (err != KErrNone)

  1036 		User::Leave(err);

  1038 	if (!sinkBufferFilledOk)

  1039 		{

  1040 		if ((err = dummySink->Error()) != KErrNone)

  1041 			User::Leave(err);

  1043 		CleanupStack::PopAndDestroy(validBuffer);

  1044 		return EFail;

  1045 		}

  1047 	if (!validBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

  1048 		{

  1049 		CleanupStack::PopAndDestroy(validBuffer);

  1050 		return EFail;

  1051 		}

  1053 	err = CheckBuffer();

  1054 	if (err)

  1055 		{

  1056 		CleanupStack::PopAndDestroy(validBuffer);

  1057 		return EFail;

  1058 		}

  1059 	CleanupStack::PopAndDestroy(validBuffer);

  1061 	validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  1062 	CleanupStack::PushL(validBuffer);

  1064 	// Randomise the valid buffer.

  1065 	iBuffer = validBuffer;

  1066 	RandomiseBuffer();

  1068 	// Test last buffer with request size.

  1069 	validBuffer->SetRequestSizeL(KTestReadSize);

  1071 	iPosition = 0;

  1072 	TRAP(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

  1073 	if (iAsynchronousRead && (err == KErrNone))

  1074 		CActiveScheduler::Start();

  1076 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  1077 	if ((err != KErrNone) && sinkBufferFilledOk)

  1078 		{

  1079 		CleanupStack::PopAndDestroy(validBuffer);

  1080 		return EFail;

  1081 		}

  1083 	if (err != KErrNone)

  1084 		User::Leave(err);

  1086 	if (!sinkBufferFilledOk)

  1087 		{

  1088 		if ((err = dummySink->Error()) != KErrNone)

  1089 			User::Leave(err);

  1091 		CleanupStack::PopAndDestroy(validBuffer);

  1092 		return EFail;

  1093 		}

  1095 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() != TUint(KTestReadSize)))

  1096 		{

  1097 		CleanupStack::PopAndDestroy(validBuffer);

  1098 		return EFail;

  1099 		}

  1101 	err = CheckBuffer();

  1102 	if (err)

  1103 		{

  1104 		CleanupStack::PopAndDestroy(validBuffer);

  1105 		return EFail;

  1106 		}

  1108 	iPosition = KTestDataSize - 10;

  1109 	TRAP(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

  1110 	if (iAsynchronousRead && (err == KErrNone))

  1111 		CActiveScheduler::Start();

  1113 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  1114 	if ((err != KErrNone) && sinkBufferFilledOk)

  1115 		{

  1116 		CleanupStack::PopAndDestroy(validBuffer);

  1117 		return EFail;

  1118 		}

  1120 	if (err != KErrNone)

  1121 		User::Leave(err);

  1123 	if (!sinkBufferFilledOk)

  1124 		{

  1125 		if ((err = dummySink->Error()) != KErrNone)

  1126 			User::Leave(err);

  1128 		CleanupStack::PopAndDestroy(validBuffer);

  1129 		return EFail;

  1130 		}

  1132 	if (!iBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

  1133 		{

  1134 		CleanupStack::PopAndDestroy(validBuffer);

  1135 		return EFail;

  1136 		}

  1138 	err = CheckBuffer();

  1139 	if (err)

  1140 		{

  1141 		CleanupStack::PopAndDestroy(validBuffer);

  1142 		return EFail;

  1143 		}

  1145 	CleanupStack::PopAndDestroy(validBuffer);

  1146 	return EPass;

  1147 	}

  1149 TVerdict TReadLastBuffer3TestStep::DoTestStepL()

  1150 	{

  1151 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  1153 	// Create valid buffer.

  1154 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  1155 	CleanupStack::PushL(validBuffer);

  1157 	// Randomise the valid buffer.

  1158 	iBuffer = validBuffer;

  1159 	RandomiseBuffer();

  1161 	// Test last buffer without request size.

  1162 	iPosition = 0;

  1163 	clip->ReadBufferL(iBuffer, iPosition);

  1165 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() != TUint(KTestBufferSize)))

  1166 		{

  1167 		CleanupStack::PopAndDestroy(validBuffer);

  1168 		return EFail;

  1169 		}

  1171 	TInt err = CheckBuffer();

  1172 	if (err)

  1173 		{

  1174 		CleanupStack::PopAndDestroy(validBuffer);

  1175 		return EFail;

  1176 		}

  1178 	iPosition = KTestDataSize-10;

  1179 	clip->ReadBufferL(iBuffer, iPosition);

  1181 	if (!validBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

  1182 		{

  1183 		CleanupStack::PopAndDestroy(validBuffer);

  1184 		return EFail;

  1185 		}

  1187 	err = CheckBuffer();

  1188 	if (err)

  1189 		{

  1190 		CleanupStack::PopAndDestroy(validBuffer);

  1191 		return EFail;

  1192 		}

  1193 	CleanupStack::PopAndDestroy(validBuffer);

  1195 	validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  1196 	CleanupStack::PushL(validBuffer);

  1198 	// Randomise the valid buffer.

  1199 	iBuffer = validBuffer;

  1200 	RandomiseBuffer();

  1202 	// Test last buffer with request size.

  1203 	validBuffer->SetRequestSizeL(KTestReadSize);

  1205 	iPosition = 0;

  1206 	clip->ReadBufferL(iBuffer, iPosition);

  1208 	if (iBuffer->LastBuffer() || (iBuffer->BufferSize() != TUint(KTestReadSize)))

  1209 		{

  1210 		CleanupStack::PopAndDestroy(validBuffer);

  1211 		return EFail;

  1212 		}

  1214 	err = CheckBuffer();

  1215 	if (err)

  1216 		{

  1217 		CleanupStack::PopAndDestroy(validBuffer);

  1218 		return EFail;

  1219 		}

  1221 	iPosition = KTestDataSize - 10;

  1222 	clip->ReadBufferL(iBuffer, iPosition);

  1224 	if (!iBuffer->LastBuffer() || (iBuffer->BufferSize() != 10))

  1225 		{

  1226 		CleanupStack::PopAndDestroy(validBuffer);

  1227 		return EFail;

  1228 		}

  1230 	err = CheckBuffer();

  1231 	if (err)

  1232 		{

  1233 		CleanupStack::PopAndDestroy(validBuffer);

  1234 		return EFail;

  1235 		}

  1237 	CleanupStack::PopAndDestroy(validBuffer);

  1238 	return EPass;

  1239 	}

  1242 TVerdict TNewSinkTestStep::DoTestStepL()

  1243 	{

  1244 	MDataSink* sink = MDataSink::NewSinkL(iUid, *iConfigDes);

  1245 	delete sink;

  1247 	return EPass;

  1248 	}

  1250 TVerdict TSinkTypeTestStep::DoTestStepL()

  1251 	{

  1252 	TUid dataSinkType = iSink->DataSinkType();

  1253 	if (dataSinkType != iUid)

  1254 		return EFail;

  1256 	TMediaId mediaId;

  1257 	TFourCC fourCC = iSink->SinkDataTypeCode(mediaId);

  1258 	if (fourCC != iFourCC)

  1259 		return EFail;

  1261 	fourCC = 0x4E554C4C; // 'LLUN'

  1262 	TInt err = iSink->SetSinkDataTypeCode(fourCC, mediaId);

  1263 	if (iCanSetSinkDataType)

  1264 		{

  1265 		if (err != KErrNone)

  1266 			User::Leave(err);

  1268 		if (iSink->SinkDataTypeCode(mediaId) != fourCC)

  1269 			return EFail;

  1271 		User::LeaveIfError(iSink->SetSinkDataTypeCode(iFourCC, mediaId));

  1272 		}

  1273 	else

  1274 		{

  1275 		if (err != KErrNotSupported)

  1276 			{

  1277 			if (err == KErrNone)

  1278 				return EFail;

  1280 			User::Leave(err);

  1281 			}

  1283 		if (iSink->SinkDataTypeCode(mediaId) != iFourCC)

  1284 			return EFail;

  1285 		}

  1287 	return EPass;

  1288 	}

  1290 TVerdict TCanCreateSinkBufferTestStep::DoTestStepL()

  1291 	{

  1292 	return (iSink->CanCreateSinkBuffer() == iCanCreateSinkBuffer) ? EPass : EFail;

  1293 	}

  1295 TVerdict TCreateSinkBufferTestStep0::DoTestStepL()

  1296 	{

  1297 	TVerdict result = EPass;

  1298 	TMediaId mediaId;

  1299 	TBool ref;

  1301 	// Create sink buffer

  1302 	CMMFBuffer* nullBuffer = iSink->CreateSinkBufferL(mediaId, ref);

  1303 	User::LeaveIfError( iSink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1304 	TBool loggedOn = ETrue;

  1306 	iSink->EmptyBufferL(nullBuffer, iSource, mediaId);

  1308 	CMMFBuffer* buffer = static_cast<CMMFDummySource*>(iSource)->MmfBuffer();

  1310 	if (ref != iExpectedRef)

  1311 		result = EFail;

  1313 	if (!buffer)

  1314 		{

  1315 		RDebug::Print(_L("*** TCreateSinkBufferTestStep:  iSink->CreateSinkBufferL returned NULL"));

  1316 		result = EFail;

  1317 		}

  1319 	if (result != EFail)

  1320 		{

  1321 		if (buffer->Type() != iExpectedType)

  1322 			result = EFail;

  1324 		if (buffer->Status() != EAvailable)

  1325 			result = EFail;

  1327 		if (buffer->Type() == KUidMmfDescriptorBuffer)

  1328 			{

  1329 			CMMFDataBuffer* dataBuffer = STATIC_CAST(CMMFDataBuffer*, buffer);

  1330 			TDes8& data = dataBuffer->Data();

  1332 			if (data.MaxLength() != iExpectedMaxLength)

  1333 				result = EFail;

  1334 			}

  1336 		buffer = NULL;

  1337 		}

  1339 	if (loggedOn)

  1340 		iSink->SinkThreadLogoff();

  1342 	if (buffer != NULL)

  1343 		result = EFail;		// buffer not deleted

  1345 	return result;

  1346 	}

  1349 TVerdict TCreateSinkBufferTestStep::DoTestPostambleL(TBool /*aCheck*/)

  1350 	{

  1351 	REComSession::FinalClose();

  1352 	return EPass;

  1353 	}

  1356 TVerdict TCreateSinkBufferTestStep1::DoTestStepL()

  1357 	{

  1358 	TVerdict result = EPass;

  1359 	TMediaId mediaId;

  1360 	TBool ref;

  1362 	TBuf8<1> dummyConfigDes;

  1363 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, dummyConfigDes);

  1364 	CleanupDeletePushL(sink);

  1366 	//DevSound WP can't call prime before login	sink->SinkPrimeL();

  1368 	// Create sink buffer

  1369 	CMMFBuffer* nullBuffer = sink->CreateSinkBufferL(mediaId, ref);

  1370 	User::LeaveIfError( sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1371 	TCleanupItem threadLogOff(DoDataSinkThreadLogoff, sink);

  1372 	CleanupStack::PushL(threadLogOff);

  1374 	//DevSound WP	sink->SinkPrimeL(); this should go after negotiate

  1375 	TCleanupItem sinkStop(DoDataSinkStop, sink);

  1376 	CleanupStack::PushL(sinkStop);

  1377 	if (!iSource)

  1378 		User::Leave(KErrNoMemory);

  1379 	if (iFormat)

  1380 		sink->NegotiateL(*iFormat);

  1381 	else

  1382 		sink->NegotiateL(*iSource);

  1383 	sink->SinkPrimeL();//DevSound WP moved from above

  1384 	sink->SinkPlayL();

  1385 	sink->EmptyBufferL(nullBuffer, iSource, mediaId);

  1386 	CActiveScheduler::Start();

  1388 	CMMFBuffer* buffer = static_cast<CMMFDummySource*>(iSource)->MmfBuffer();

  1390 	if (ref != iExpectedRef)

  1391 		result = EFail;

  1393 	if (!buffer)

  1394 		{

  1395 		RDebug::Print(_L("*** TCreateSinkBufferTestStep:  sink->CreateSinkBufferL returned NULL"));

  1396 		result = EFail;

  1397 		}

  1399 	if (result != EFail)

  1400 		{

  1401 		if (buffer->Type() != iExpectedType)

  1402 			result = EFail;

  1404 		//	DevSound WP buffers are owned and controller by

  1405 		//	HwPlugins test should not make assumptions

  1406 		//  if (buffer->Status() != EAvailable)

  1407 		//	result = EFail;

  1409 		if (buffer->Type() == KUidMmfDescriptorBuffer)

  1410 			{

  1411 			/*

  1412 			DevSound WP buffers are owned and controller by

  1413 			HwPlugins test should not make assumptions

  1414 			CMMFDataBuffer* dataBuffer = STATIC_CAST(CMMFDataBuffer*, buffer);

  1415 			TDes8& data = dataBuffer->Data();

  1417 			if (data.MaxLength() != iExpectedMaxLength)

  1418 				result = EFail;

  1419 			*/

  1420 			}

  1422 		buffer = NULL;

  1423 		}

  1425 	// Re-test after logging on. (iNeedsSWConversion = ETrue)

  1426 	User::LeaveIfError(sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))));

  1428 	CleanupStack::PopAndDestroy(3, sink);	// sinkStop, threadLogOff, sink

  1430 	//	if (buffer != NULL) DevSound WP might not be null if was never created

  1431 	//		result = EFail; also not test apps buffer to delete

  1433 	return result;

  1434 	}

  1436 TVerdict TCreateSinkBufferTestStep2::DoTestStepL()

  1437 	{

  1438 	TVerdict result = EPass;

  1439 	TMediaId mediaId;

  1440 	TBool ref;

  1442 	TBuf8<1> dummyConfigDes;

  1443 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, dummyConfigDes);

  1444 	CleanupDeletePushL(sink);

  1445 	sink->SinkPrimeL();

  1447 	// Create sink buffer

  1448 	CMMFBuffer* nullBuffer = sink->CreateSinkBufferL(mediaId, ref);

  1449 	User::LeaveIfError( sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1450 	TCleanupItem threadLogOff(DoDataSinkThreadLogoff, sink);

  1451 	CleanupStack::PushL(threadLogOff);

  1453 	sink->SinkPrimeL();

  1454 	TCleanupItem sinkStop(DoDataSinkStop, sink);

  1455 	CleanupStack::PushL(sinkStop);

  1456 	if (!iSource)

  1457 		User::Leave(KErrArgument);

  1458 	if (iFormat)

  1459 		sink->NegotiateL(*iFormat);

  1460 	else

  1461 		sink->NegotiateL(*iSource);

  1462 	sink->SinkPlayL();

  1463 	sink->EmptyBufferL(nullBuffer, iSource, mediaId);

  1464 	CActiveScheduler::Start();

  1466 	CMMFBuffer* buffer = static_cast<CMMFDummySource*>(iSource)->MmfBuffer();

  1468 	if (ref != iExpectedRef)

  1469 		result = EFail;

  1471 	if (!buffer)

  1472 		{

  1473 		RDebug::Print(_L("*** TCreateSinkBufferTestStep:  sink->CreateSinkBufferL returned NULL"));

  1474 		result = EFail;

  1475 		}

  1477 	if (result != EFail)

  1478 		{

  1479 		if (buffer->Type() != iExpectedType)

  1480 			result = EFail;

  1482 		if (buffer->Status() != EAvailable)

  1483 			result = EFail;

  1485 		if (buffer->Type() == KUidMmfDescriptorBuffer)

  1486 			{

  1487 			CMMFDataBuffer* dataBuffer = STATIC_CAST(CMMFDataBuffer*, buffer);

  1488 			TDes8& data = dataBuffer->Data();

  1490 			if (data.MaxLength() != iExpectedMaxLength)

  1491 				result = EFail;

  1492 			}

  1494 		buffer = NULL;

  1495 		}

  1497 	// Test the rest...

  1498 	TFourCC fourCC = KMMFFourCCCodePCM16;

  1499 	TFourCC emptyFourCC;

  1501 	TBufC8<5> fourCCString(KEmptyFourCCCode);

  1502 	TPtr8 fourCCPtr = fourCCString.Des();

  1503 	TPtr8 fourCCPtr1(&fourCCPtr[0], 4);

  1504 	emptyFourCC.FourCC(&fourCCPtr1);

  1505 	TInt err = sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource)));

  1506 	if (err != KErrNone)

  1507 		{

  1508 	  //RDebug::Print(_L("Audio Output: Expecting error %d, got %d"), KErrNone, err);(Commented under DEF105143)

  1509 		result = EFail;

  1510 		}

  1512 	TRAP(err, sink->NegotiateL(*iSource));

  1513 	if (err != KErrNotSupported)

  1514 		{

  1515 	//	RDebug::Print(_L("Audio Output: Expecting error %d, got %d"), KErrNotSupported, err);(Commented under DEF105143)

  1516 		result = EFail;

  1517 		}

  1519 	if ((sink->SinkDataTypeCode(mediaId) != fourCC) && (sink->SinkDataTypeCode(mediaId) != emptyFourCC))

  1520 		{

  1521 		RDebug::Print(_L("Audio Output: NegotiateL sink code does not match\n"));

  1522 		result = EFail;

  1523 		}

  1525 	sink->SinkPrimeL();

  1526 	TRAP(err, sink->SinkPlayL());

  1527 	if (err != KErrNotSupported)

  1528 		{

  1529 	//	RDebug::Print(_L("Audio Output: Expecting error %d, got %d"), KErrNotSupported, err);(Commented under DEF105143)

  1530 		result = EFail;

  1531 		}

  1532 	sink->SinkPauseL();

  1533 	sink->SinkStopL();

  1535 	TMMFPrioritySettings prioritySettings;

  1536 	sink->SetSinkPrioritySettings(prioritySettings);

  1537 	sink->SinkThreadLogoff();

  1539 	CleanupStack::PopAndDestroy(3, sink);	// sinkStop, threadLogOff, sink

  1541 	if (buffer != NULL)

  1542 		result = EFail;

  1544 	return result;

  1545 	}

  1547 TVerdict TCreateSinkBufferTestStep3::DoTestStepL()

  1548 	{

  1549 	TVerdict result = EPass;

  1550 	TMediaId mediaId;

  1551 	TBool ref;

  1552 	// DevSoundWP - The source file is pcmu8 not pcm16

  1553 	// on 7.0s audio output this didn't matter as it could only

  1554 	// accept pcm16 - 8.0 can accept pcmu8 as well

  1555 	// TFourCC fourCC = KMMFFourCCCodePCM16;

  1556 	TFourCC fourCC = KMMFFourCCCodePCMU8;

  1557 	TFourCC emptyFourCC;

  1558 	TMMFPrioritySettings prioritySettings;

  1560 	TBuf8<1> dummyConfigDes;

  1561 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, dummyConfigDes);

  1562 	CleanupDeletePushL(sink);

  1564 	//DevSound WP - need to rest this as buffer may not be emptied ok if OOM in AS occurs

  1565 	static_cast<CMMFDummySource*>(iSource)->ResetBufferEmptiedOk();

  1567 	//DevSound WP must call logon before prime

  1568 	User::LeaveIfError( sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1569 	sink->SinkPrimeL();

  1571 	// Create sink buffer

  1572 	CMMFBuffer* nullBuffer = sink->CreateSinkBufferL(mediaId, ref);

  1573 	//DevSound WP must call logon before prime

  1574 //	User::LeaveIfError( sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1575 	TCleanupItem threadLogOff(DoDataSinkThreadLogoff, sink);

  1576 	CleanupStack::PushL(threadLogOff);

  1578 	sink->SinkPrimeL();

  1579 	TCleanupItem sinkStop(DoDataSinkStop, sink);

  1580 	CleanupStack::PushL(sinkStop);

  1581 	if (!iSource)

  1582 		User::Leave(KErrNoMemory);

  1583 	if (iFormat)

  1584 		sink->NegotiateL(*iFormat);

  1585 	else

  1586 		sink->NegotiateL(*iSource);

  1587 	sink->SinkPlayL();

  1588 	sink->EmptyBufferL(nullBuffer, iSource, mediaId);

  1589 	CActiveScheduler::Start();

  1591 	CMMFBuffer* buffer = static_cast<CMMFDummySource*>(iSource)->MmfBuffer();

  1593 	if ((buffer) && (static_cast<CMMFDummySource*>(iSource)->BufferEmptiedOk()))

  1594 		{//DevSound WP buffer not emptied ok if OOM in AS

  1596 		if (ref != iExpectedRef)

  1597 			result = EFail;

  1599 		if (!buffer)

  1600 			{

  1601 			RDebug::Print(_L("*** TCreateSinkBufferTestStep:  sink->CreateSinkBufferL returned NULL"));

  1602 			result = EFail;

  1603 			}

  1605 		if (result != EFail)

  1606 			{

  1607 			if (buffer->Type() != iExpectedType)

  1608 				result = EFail;

  1610 			if (buffer->Status() != EAvailable)

  1611 				result = EFail;

  1613 			buffer = NULL;

  1614 			}

  1616 		// Test the rest...

  1617 		if ((sink->SinkDataTypeCode(mediaId) != fourCC) && (sink->SinkDataTypeCode(mediaId) != emptyFourCC))

  1618 			{

  1619 			RDebug::Print(_L("Audio Output: NegotiateL sink code does not match\n"));

  1620 			result = EFail;

  1621 			}

  1623 		User::LeaveIfError(sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))));

  1624 		sink->SinkPrimeL();

  1625 		sink->SinkPlayL();

  1626 		sink->SinkPauseL();

  1627 		sink->SinkStopL();

  1629 		sink->SetSinkPrioritySettings(prioritySettings);

  1630 		}

  1632 	CleanupStack::PopAndDestroy(3, sink);	// sinkStop, threadLogOff, sink

  1634 //	if (buffer != NULL) DevSound WP  OOM in AS may not be null

  1635 //		result = EFail;

  1637 	return result;

  1638 	}

  1641 TVerdict TCreateSinkBufferTestStep4::DoTestStepL()

  1642 	{

  1643 	TVerdict result = EPass;

  1644 	TMediaId mediaId;

  1645 	TBool ref;

  1647 	// DevSoundWP - The source file is pcmu8 not pcm16

  1648 	// however the sample rate is non standard and so

  1649 	// the conversion is done in audio output which means the

  1650 	// datatype is still pcm16

  1651 	TFourCC fourCC = KMMFFourCCCodePCM16;

  1652 	//TFourCC fourCC = KMMFFourCCCodePCMU8;

  1654 	TFourCC emptyFourCC;

  1655 	TMMFPrioritySettings prioritySettings;

  1657 	TBuf8<1> dummyConfigDes;

  1658 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, dummyConfigDes);

  1659 	CleanupDeletePushL(sink);

  1660 	//	DevSoundWP Prime should be after logon sink->SinkPrimeL();

  1662 	// Create sink buffer

  1663 	CMMFBuffer* nullBuffer = sink->CreateSinkBufferL(mediaId, ref);

  1665 	//DevSound WP needs resetting as buffer is not emptied ok during OOM in AS

  1666 	static_cast<CMMFDummySource*>(iSource)->ResetBufferEmptiedOk();

  1668 	User::LeaveIfError( sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))) );

  1669 	TCleanupItem threadLogOff(DoDataSinkThreadLogoff, sink);

  1670 	CleanupStack::PushL(threadLogOff);

  1672 	sink->SinkPrimeL();

  1673 	TCleanupItem sinkStop(DoDataSinkStop, sink);

  1674 	CleanupStack::PushL(sinkStop);

  1675 	if (!iSource)

  1676 		User::Leave(KErrNoMemory);

  1677 	if (iFormat)

  1678 		sink->NegotiateL(*iFormat);

  1679 	else

  1680 		sink->NegotiateL(*iSource);

  1681 	sink->SinkPlayL();

  1682 	sink->EmptyBufferL(nullBuffer, iSource, mediaId);

  1683 	CActiveScheduler::Start();

  1685 	CMMFBuffer* buffer = static_cast<CMMFDummySource*>(iSource)->MmfBuffer();

  1687 	if ((buffer) && (static_cast<CMMFDummySource*>(iSource)->BufferEmptiedOk()))

  1688 		{//DevSound WP buffer not emptied ok if OOM in AS

  1690 		if (ref != iExpectedRef)

  1691 			result = EFail;

  1693 		if (!buffer)

  1694 			{

  1695 			RDebug::Print(_L("*** TCreateSinkBufferTestStep:  sink->CreateSinkBufferL returned NULL"));

  1696 			result = EFail;

  1697 			}

  1699 		if (result != EFail)

  1700 			{

  1701 			if (buffer->Type() != iExpectedType)

  1702 				result = EFail;

  1704 			if (buffer->Status() != EAvailable)

  1705 				result = EFail;

  1707 			/*

  1708 		DevSound WP buffers are owned and controller by

  1709 		HwPlugins test should not make assumptions

  1710 #ifdef __USE_MMF_TRANSFERBUFFERS__

  1711 		if (buffer->Type() == KUidMmfTransferBuffer)

  1712 #else

  1713 		if (buffer->Type() == KUidMmfDescriptorBuffer)

  1714 #endif

  1715 			{

  1716 			CMMFDataBuffer* dataBuffer = STATIC_CAST(CMMFDataBuffer*, buffer);

  1717 			TDes8& data = dataBuffer->Data();

  1719 			if (data.MaxLength() != iExpectedMaxLength)

  1720 				result = EFail;

  1721 			}

  1722 		else

  1723 			result = EFail;

  1724 		*/

  1727 			buffer = NULL;

  1728 			}

  1730 		// Test the rest...

  1731 		if ((sink->SinkDataTypeCode(mediaId) != fourCC) && (sink->SinkDataTypeCode(mediaId) != emptyFourCC))

  1732 			{

  1733 			RDebug::Print(_L("Audio Output: NegotiateL sink code does not match\n"));

  1734 			result = EFail;

  1735 			}

  1737 		User::LeaveIfError(sink->SinkThreadLogon(*(static_cast<CMMFDummySource*>(iSource))));

  1738 		sink->SinkPrimeL();

  1739 		sink->SinkPlayL();

  1740 		sink->SinkPauseL();

  1741 		sink->SinkStopL();

  1743 		sink->SetSinkPrioritySettings(prioritySettings);

  1745 		}

  1747 	CleanupStack::PopAndDestroy(3, sink);	// sinkStop, threadLogOff, sink

  1749 //	if (buffer != NULL) DevSound WP if OOM in AS may not be null

  1750 //		result = EFail;

  1752 	return result;

  1753 	}

  1756 TVerdict TSinkThreadLogonTestStep::DoTestStepL()

  1757 	{

  1758 	User::LeaveIfError(iSink->SinkThreadLogon(*iEventHandler));

  1760 	iSink->SinkThreadLogoff();

  1762 	return EPass;

  1763 	}

  1765 TVerdict TNegotiateTestStep::DoTestStepL()

  1766 	{

  1767 	iSink->NegotiateL(*iSource);

  1768 	return EPass;

  1769 	}

  1771 TVerdict TEmptyBufferTestStep::DoTestStepL()

  1772 	{

  1773 	RandomiseBuffer();

  1775 	TMediaId mediaId;

  1776 	TRAPD(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  1778 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  1779 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  1780 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  1781 		return EFail;

  1783 	if (err != KErrNone)

  1784 		{

  1785 		TInt destinationLength = iDestinationDes.MaxLength();

  1786 		if (Mem::Compare(iDestinationDes.Ptr(), destinationLength, iCopyOfDestinationDes.Ptr(), destinationLength))

  1787 			return EFail;

  1789 		User::Leave(err);

  1790 		}

  1792 	if (!sourceBufferEmptiedOk)

  1793 		return EFail;

  1795 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  1796 	TInt writeLength = buffer->BufferSize();

  1797 	if (writeLength != iWriteLength)

  1798 		return EFail;

  1800 	if (iCopyOfDestinationDes.Length()<(iPosition+iWriteLength))

  1801 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  1803 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  1804 	iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  1805 	iPosition += writeLength;

  1806 	return EPass;

  1807 	}

  1810 // TClipBytesFreeTestStep

  1811 // Test that the number of bytes free is what we expect.

  1812 // Zero bytes free is also an acceptable result, when file failures are expected.

  1813 TVerdict TClipBytesFreeTestStep::DoTestStepL()

  1814 	{

  1815 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  1816 	TInt64 bytesFree = clip->BytesFree();

  1818 	// tolerance incase another process accesses file system during test

  1819 	TInt64 tolerance = 8192;		// 2 blocks of 4096 bytes

  1821 	// FileServer file failure simulation is currently only supported on WINS

  1822 	// so ignore the iFileFailureExpected on target builds

  1824 	TVerdict result = EFail;

  1825 	if ((bytesFree == iExpectedBytesFree) || (Abs(bytesFree - iExpectedBytesFree) <= tolerance))

  1826 		{

  1827 		result = EPass;

  1828 		}

  1829 	else if (iFileFailureExpected && (bytesFree == 0))

  1830 		{

  1831 		result = EPass;

  1832 		}

  1834 	return result;

  1835 	}

  1837 // TClipSizeTestStep

  1838 // Test that the size of the clip is what we expect.

  1839 // Zero bytes free is also an acceptable result, when file failures are expected.

  1840 TVerdict TClipSizeTestStep::DoTestStepL()

  1841 	{

  1842 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  1843 	TInt size = clip->Size();

  1845 	return (size == iExpectedSize)  || ((size == 0) && iFileFailureExpected) ? EPass : EFail;

  1846 	}

  1848 // TClipDeleteTestStep

  1849 // Attempt to delete the clip.

  1850 // The test leaves if there is an error.

  1851 TVerdict TClipDeleteTestStep::DoTestStepL()

  1852 	{

  1853 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  1854 	User::LeaveIfError(clip->Delete());

  1856 	return EPass;

  1857 	}

  1859 // TClipSetSizeTestStep

  1860 // Attempt to set the size of the clip

  1861 // Test that the results are correct, in the case when setting the size is supported.

  1862 // In the case when it is not supported check that the size does not change.

  1863 TVerdict TClipSetSizeTestStep::DoTestStepL()

  1864 	{

  1865 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  1867 	TInt size;

  1868 	TInt oldSize = clip->Size();

  1869 	if (oldSize <= 0)

  1870 		{

  1871 		if (iFileFailureExpected && (oldSize == 0))

  1872 			User::Leave(KErrFileFail);

  1874 		return EFail;

  1875 		}

  1877 	TInt newSize = oldSize+1;

  1878 	TInt err = clip->SetSize(newSize);

  1879 	if (iCanSetSize)

  1880 		{

  1881 		if (err != KErrNone)

  1882 			User::Leave(err);

  1884 		if ((size = clip->Size()) != newSize)

  1885 			{

  1886 			if (iFileFailureExpected && (size == 0))

  1887 				User::Leave(KErrFileFail);

  1889 			return EFail;

  1890 			}

  1891 		}

  1892 	else

  1893 		{

  1894 		if (err != KErrNotSupported)

  1895 			{

  1896 			if (err == KErrNone)

  1897 				return EFail;

  1899 			User::Leave(err);

  1900 			}

  1902 		if ((size = clip->Size()) != oldSize)

  1903 			{

  1904 			if (iFileFailureExpected && (size == 0))

  1905 				User::Leave(KErrFileFail);

  1907 			return EFail;

  1908 			}

  1909 		}

  1911 	return EPass;

  1912 	}

  1915 TVerdict TClipReadBufferTestStep::DoTestStepL()

  1916 	{

  1917 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  1919 	RandomiseBuffer();

  1920 	TRAPD(err, clip->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  1921 	if (iAsynchronousRead && (err == KErrNone))

  1922 		CActiveScheduler::Start();

  1924 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  1925 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  1926 	if ((err != KErrNone) && sinkBufferFilledOk)

  1927 		return EFail;

  1929 	if (err != KErrNone)

  1930 		User::Leave(err);

  1932 	if (!sinkBufferFilledOk)

  1933 		{

  1934 		if ((err = dummySink->Error()) != KErrNone)

  1935 			User::Leave(err);

  1937 		return EFail;

  1938 		}

  1940 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  1941 	TInt readLength = buffer->BufferSize();

  1942 	if (readLength < iReadLength) // Reading more data than we asked for is ok.

  1943 		return EFail;

  1945 	err = CheckBuffer();

  1946 	return (err == 0) ? EPass : EFail;

  1947 	}

  1949 TVerdict TClipReadBuffer2TestStep::DoTestStepL()

  1950 	{

  1951 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  1953 	RandomiseBuffer();

  1954 	TRAPD(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

  1955 	if (iAsynchronousRead && (err == KErrNone))

  1956 		CActiveScheduler::Start();

  1958 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  1959 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  1960 	if ((err != KErrNone) && sinkBufferFilledOk)

  1961 		return EFail;

  1963 	if (err != KErrNone)

  1964 		User::Leave(err);

  1966 	if (!sinkBufferFilledOk)

  1967 		{

  1968 		if ((err = dummySink->Error()) != KErrNone)

  1969 			User::Leave(err);

  1971 		return EFail;

  1972 		}

  1974 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  1975 	TInt readLength = buffer->BufferSize();

  1976 	if (readLength != iReadLength)

  1977 		return EFail;

  1979 	err = CheckBuffer();

  1980 	return (err == 0) ? EPass : EFail;

  1981 	}

  1983 TVerdict TClipReadBuffer3TestStep::DoTestStepL()

  1984 	{

  1985 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  1987 	RandomiseBuffer();

  1988 	clip->ReadBufferL(iBuffer, iPosition);

  1990 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  1991 	TInt readLength = buffer->BufferSize();

  1992 	if (readLength != iReadLength)

  1993 		return EFail;

  1995 	TInt err = CheckBuffer();

  1996 	return (err == 0) ? EPass : EFail;

  1997 	}

  1999 TVerdict TClipReadBuffer4TestStep::DoTestStepL()

  2000 	{

  2001 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  2003 	RandomiseBuffer();

  2004 	TRAPD(err, clip->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  2006 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2007 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2008 	if ((err != KErrNone) && sinkBufferFilledOk)

  2009 		return EFail;

  2011 	if (err != KErrNone)

  2012 		User::Leave(err);

  2014 	if (!sinkBufferFilledOk)

  2015 		return EFail;

  2017 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2018 	TInt readLength = buffer->BufferSize();

  2019 	if (readLength != iExpectedReadLength)

  2020 		return EFail;

  2022 	err = CheckBuffer();

  2023 	return (err == 0) ? EPass : EFail;

  2024 	}

  2027 TVerdict TDescriptorClipWriteBufferTestStep::DoTestStepL()

  2028 	{

  2029 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  2031 	RandomiseBuffer();

  2032 	TRAPD(err, clip->WriteBufferL(iWriteLength, iBuffer, iPosition, iSource));

  2034 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  2035 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  2036 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  2037 		return EFail;

  2039 	if (err != KErrNone)

  2040 		User::Leave(err);

  2042 	if (!sourceBufferEmptiedOk)

  2043 		return EFail;

  2045 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2047 	TInt position = iPosition;

  2048 	if (iCopyOfDestinationDes.Length()<iPosition)

  2049 		position = iCopyOfDestinationDes.Length();

  2051 	if (iCopyOfDestinationDes.Length()<(position+iWriteLength))

  2052 		iCopyOfDestinationDes.SetLength(position+iWriteLength);

  2054 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  2055 	iCopyOfDestinationDes.Replace(position, iWriteLength, bufferData);

  2056 	return EPass;

  2057 	}

  2059 TVerdict TDescriptorClipWriteBuffer2TestStep::DoTestStepL()

  2060 	{

  2061 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  2063 	RandomiseBuffer();

  2064 	TRAPD(err, clip->WriteBufferL(iBuffer, iPosition, iSource));

  2066 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  2067 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  2068 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  2069 		return EFail;

  2071 	if (err != KErrNone)

  2072 		User::Leave(err);

  2074 	if (!sourceBufferEmptiedOk)

  2075 		return EFail;

  2077 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2078 	TInt writeLength = buffer->BufferSize();

  2079 	if (writeLength != iWriteLength)

  2080 		return EFail;

  2082 	TInt position = iPosition;

  2083 	if (iCopyOfDestinationDes.Length()<iPosition)

  2084 		position = iCopyOfDestinationDes.Length();

  2086 	if (iCopyOfDestinationDes.Length()<(position+iWriteLength))

  2087 		iCopyOfDestinationDes.SetLength(position+iWriteLength);

  2089 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  2090 	iCopyOfDestinationDes.Replace(position, iWriteLength, bufferData);

  2091 	return EPass;

  2092 	}

  2094 TVerdict TDescriptorClipWriteBuffer3TestStep::DoTestStepL()

  2095 	{

  2096 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  2098 	RandomiseBuffer();

  2099 	clip->WriteBufferL(iBuffer, iPosition);

  2101 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2102 	TInt writeLength = buffer->BufferSize();

  2103 	if (writeLength != iWriteLength)

  2104 		return EFail;

  2106 	TInt position = iPosition;

  2107 	if (iCopyOfDestinationDes.Length()<iPosition)

  2108 		position = iCopyOfDestinationDes.Length();

  2110 	if (iCopyOfDestinationDes.Length()<(position+iWriteLength))

  2111 		iCopyOfDestinationDes.SetLength(position+iWriteLength);

  2113 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  2114 	iCopyOfDestinationDes.Replace(position, iWriteLength, bufferData);

  2115 	return EPass;

  2116 	}

  2118 TVerdict TNewFileSourceTestStep::DoTestStepL()

  2119 	{

  2120 	CMMFFile* source = STATIC_CAST(CMMFFile*, MDataSource::NewSourceL(iUid, *iConfigDes));

  2121 	CleanupStack::PushL(source);

  2122 	source->SourcePrimeL();

  2124 	CleanupStack::PopAndDestroy(source);

  2125 	return EPass;

  2126 	}

  2128 TInt TFileSourceThreadLogonThread(TAny* initPtr)

  2129 	{

  2130 	TThreadData &threadData = *REINTERPRET_CAST(TThreadData*, initPtr);

  2131 	CMMFFile* source = threadData.iFilePtr;

  2132 	MAsyncEventHandler* eventHandler = threadData.iEventHandler;

  2134 	threadData.iErr = KErrNone;

  2136 	threadData.iErr = source->SourceThreadLogon(*eventHandler);

  2137 	if (threadData.iErr == KErrNone)

  2138 		{

  2139 		threadData.iFileSize = source->Size();

  2140 		source->SourceThreadLogoff();

  2141 		}

  2144 	return 0;

  2145 	}

  2147 TVerdict TFileSourceThreadLogonTestStep::DoTestStepL()

  2148 	{

  2150 	TThreadData threadData; // Is this going to work on target? (or do we need to package the data and use RThread::ReadL/WriteL?)

  2151 	threadData.iFilePtr = STATIC_CAST(CMMFFile*, iSource);

  2152 	threadData.iEventHandler = iEventHandler;

  2154 	TRequestStatus logonStatus;

  2156 	RThread sourceThread;

  2157 	User::LeaveIfError(sourceThread.Create(_L("TFileSourceThreadLogonThread"), TFileSourceThreadLogonThread, KDefaultStackSize, NULL, &threadData));

  2158 	CleanupClosePushL(sourceThread);

  2160 	sourceThread.Logon(logonStatus);

  2161 	if(logonStatus != KRequestPending)

  2162 		{

  2163 		User::Leave(logonStatus.Int());

  2164 		}

  2165 	sourceThread.Resume();

  2167 	User::WaitForRequest(logonStatus);

  2168 	if(logonStatus != KErrNone)

  2169 		{

  2170 		User::Leave(logonStatus.Int());

  2171 		}

  2173 	if (threadData.iErr != KErrNone)

  2174 		User::Leave(threadData.iErr);

  2176 	if ((threadData.iFileSize != iFileSize))

  2177 		{

  2178 		if (!iFileFailureExpected)

  2179 			return EFail;

  2181 		if (threadData.iFileSize != 0)

  2182 			return EFail;

  2183 		}

  2185 	CleanupStack::PopAndDestroy(1); // sourceThread

  2186 	return EPass;

  2187 	}

  2189 TVerdict TFileFillBufferTestStep::DoTestStepL()

  2190 	{

  2191 	RandomiseBuffer();

  2193 	TMediaId mediaId;

  2195 	RFs fs;

  2196 	User::LeaveIfError(fs.Connect());

  2197 	CleanupClosePushL(fs);

  2198 	MDataSource* source = CreateFileSourceL(iSourceType, fs, iFileName);

  2199 	CleanupDeletePushL(source);

  2201 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2202 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2203 	source->SourcePrimeL();

  2205 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  2206 	if (iAsynchronousRead && (err == KErrNone))

  2207 		CActiveScheduler::Start();

  2208 	CleanupStack::PopAndDestroy(2, &fs); // source, fs

  2210 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2211 	if ((err != KErrNone) && sinkBufferFilledOk)

  2212 		return EFail;

  2214 	if (err != KErrNone)

  2215 		User::Leave(err);

  2217 	if (!sinkBufferFilledOk)

  2218 		{

  2219 		if ((err = dummySink->Error()) != KErrNone)

  2220 			User::Leave(err);

  2222 		return EFail;

  2223 		}

  2225 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2226 	TInt readLength = buffer->BufferSize();

  2227 	if (readLength != iReadLength)

  2228 		return EFail;

  2230 	err = CheckBuffer();

  2231 	return (err == 0) ? EPass : EFail;

  2232 	}

  2234 TVerdict TFileFillBuffer2TestStep::DoTestStepL()

  2235 	{

  2236 	TMediaId mediaId;

  2237 	RFs fs;

  2238 	User::LeaveIfError(fs.Connect());

  2239 	CleanupClosePushL(fs);

  2240 	MDataSource* source = CreateFileSourceL(iSourceType, fs, iFileName);

  2241 	CleanupDeletePushL(source);

  2243 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2244 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2245 	source->SourcePrimeL();

  2247 	TInt readLength;

  2248 	TVerdict result = EPass;

  2249 	iPosition = 0;

  2250 	do

  2251 		{

  2252 		RandomiseBuffer();

  2254 		TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  2255 		if (iAsynchronousRead && (err == KErrNone))

  2256 			CActiveScheduler::Start();

  2258 		TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2259 		if ((err != KErrNone) && sinkBufferFilledOk)

  2260 			{

  2261 			result = EFail;

  2262 			break;

  2263 			}

  2265 		if (err != KErrNone)

  2266 			User::Leave(err);

  2268 		if (!sinkBufferFilledOk)

  2269 			{

  2270 			if ((err = dummySink->Error()) != KErrNone)

  2271 				User::Leave(err);

  2273 			result = EFail;

  2274 			break;

  2275 			}

  2277 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2278 		readLength = buffer->BufferSize();

  2280 		err = CheckBuffer();

  2281 		iPosition += readLength;

  2283 		if (err != 0)

  2284 			{

  2285 			result = EFail;

  2286 			break;

  2287 			}

  2288 		}

  2289 	while (readLength != 0);

  2291 	CleanupStack::PopAndDestroy(2, &fs); // source, fs

  2292 	return result;

  2293 	}

  2295 TVerdict TFileFillBuffer3TestStep::DoTestStepL()

  2296 	{

  2297 	TMediaId mediaId;

  2298 	RFs fs;

  2299 	User::LeaveIfError(fs.Connect());

  2300 	CleanupClosePushL(fs);

  2301 	MDataSource* source = CreateFileSourceL(iSourceType, fs, iFileName);

  2302 	CleanupDeletePushL(source);

  2304 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2305 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2306 	source->SourcePrimeL();

  2308 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2309 	TInt maxRequestCount = bufferArray.Count();

  2310 	TInt err = KErrNone;

  2311 	iPosition = 0;

  2312 	TInt requestCount;

  2313 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2314 		{

  2315 		iBuffer = bufferArray[requestCount];

  2316 		RandomiseBuffer();

  2318 		TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

  2319 		if (err != KErrNone)

  2320 			break;

  2321 		}

  2323 	if (requestCount)

  2324 		{

  2325 		if (requestCount>iMaxRequestCount)

  2326 			requestCount = iMaxRequestCount;

  2328 		dummySink->SetExpectedFillCount(requestCount);

  2329 		CActiveScheduler::Start();

  2330 		}

  2332 	CleanupStack::PopAndDestroy(2, &fs);

  2334 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2335 	if (!requestCount && sinkBufferFilledOk)

  2336 		return EFail;

  2338 	if (!sinkBufferFilledOk && requestCount)

  2339 		{

  2340 		if ((err = dummySink->Error()) != KErrNone)

  2341 			User::Leave(err);

  2343 		return EFail;

  2344 		}

  2346 	TInt completionCount;

  2347 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2348 		{

  2349 		iBuffer = bufferArray[completionCount];

  2350 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2351 		TInt readLength = buffer->BufferSize();

  2352 		if (readLength != iReadLength)

  2353 			return EFail;

  2355 		err = CheckBuffer();

  2356 		iPosition += readLength;

  2357 		if (err != 0)

  2358 			return EFail;

  2359 		}

  2361 	if (err != KErrNone)

  2362 		User::Leave(err);

  2364 	return EPass;

  2365 	}

  2367 TVerdict TFileFillBuffer4TestStep::DoTestStepL()

  2368 	{

  2369 	TMediaId mediaId;

  2370 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2371 	TInt maxRequestCount = bufferArray.Count();

  2372 	TInt err = KErrNone;

  2373 	TInt requestCount;

  2374 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2375 		{

  2376 		iBuffer = bufferArray[requestCount];

  2377 		RandomiseBuffer();

  2379 		TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  2380 		if (err != KErrNone)

  2381 			break;

  2382 		}

  2384 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2385 	if (requestCount)

  2386 		{

  2387 		if (requestCount>iMaxRequestCount)

  2388 			requestCount = iMaxRequestCount;

  2390 		dummySink->SetExpectedFillCount(requestCount);

  2391 		CActiveScheduler::Start();

  2392 		}

  2394 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2395 	if (!requestCount && sinkBufferFilledOk)

  2396 		return EFail;

  2398 	if (!sinkBufferFilledOk && requestCount)

  2399 		{

  2400 		if ((err = dummySink->Error()) != KErrNone)

  2401 			User::Leave(err);

  2403 		return EFail;

  2404 		}

  2406 	TInt completionCount;

  2407 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2408 		{

  2409 		iBuffer = bufferArray[completionCount];

  2410 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2411 		TInt readLength = buffer->BufferSize();

  2412 		if (readLength != iReadLength)

  2413 			return EFail;

  2415 		err = CheckBuffer();

  2416 		iPosition += readLength;

  2417 		if (err != 0)

  2418 			return EFail;

  2419 		}

  2421 	if (err != KErrNone)

  2422 		User::Leave(err);

  2424 	iSource->FillBufferL(bufferArray[completionCount], iSink, mediaId);

  2425 	return EPass;

  2426 	}

  2428 TVerdict TFileReadBufferTestStep::DoTestStepL()

  2429 	{

  2430 	RFs fs;

  2431 	User::LeaveIfError(fs.Connect());

  2432 	CleanupClosePushL(fs);

  2433 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2434 	CleanupDeletePushL(source);

  2436 	CMMFDummySink* sink = STATIC_CAST(CMMFDummySink*, iSink);

  2437 	User::LeaveIfError(source->SourceThreadLogon(*sink));

  2438 	source->SourcePrimeL();

  2440 	RandomiseBuffer();

  2441 	TRAPD(err, source->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  2442 	if (iAsynchronousRead && (err == KErrNone))

  2443 		CActiveScheduler::Start();

  2444 	CleanupStack::PopAndDestroy(2, &fs);

  2446 	TBool sinkBufferFilledOk = sink->BufferFilledOk();

  2447 	if ((err != KErrNone) && sinkBufferFilledOk)

  2448 		return EFail;

  2450 	if (err != KErrNone)

  2451 		User::Leave(err);

  2453 	if (!sinkBufferFilledOk)

  2454 		{

  2455 		if ((err = sink->Error()) != KErrNone)

  2456 			User::Leave(err);

  2458 		return EFail;

  2459 		}

  2461 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2462 	TInt readLength = buffer->BufferSize();

  2463 	if (readLength < iReadLength) // Reading more data than we asked for is ok.

  2464 		return EFail;

  2466 	err = CheckBuffer();

  2467 	return (err == 0) ? EPass : EFail;

  2468 	}

  2470 TVerdict TFileReadBuffer2TestStep::DoTestStepL()

  2471 	{

  2472 	RFs fs;

  2473 	User::LeaveIfError(fs.Connect());

  2474 	CleanupClosePushL(fs);

  2475 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2476 	CleanupDeletePushL(source);

  2478 	CMMFDummySink* sink = STATIC_CAST(CMMFDummySink*, iSink);

  2479 	User::LeaveIfError(source->SourceThreadLogon(*sink));

  2480 	source->SourcePrimeL();

  2482 	RandomiseBuffer();

  2483 	TRAPD(err, source->ReadBufferL(iBuffer, iPosition, iSink));

  2484 	if (iAsynchronousRead && (err == KErrNone))

  2485 		CActiveScheduler::Start();

  2486 	CleanupStack::PopAndDestroy(2, &fs); // source, fs

  2488 	TBool sinkBufferFilledOk = sink->BufferFilledOk();

  2489 	if ((err != KErrNone) && sinkBufferFilledOk)

  2490 		return EFail;

  2492 	if (err != KErrNone)

  2493 		User::Leave(err);

  2495 	if (!sinkBufferFilledOk)

  2496 		{

  2497 		if ((err = sink->Error()) != KErrNone)

  2498 			User::Leave(err);

  2500 		return EFail;

  2501 		}

  2503 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2504 	TInt readLength = buffer->BufferSize();

  2505 	if (readLength != iReadLength)

  2506 		return EFail;

  2508 	err = CheckBuffer();

  2509 	return (err == 0) ? EPass : EFail;

  2510 	}

  2512 TVerdict TFileReadBuffer3TestStep::DoTestStepL()

  2513 	{

  2514 	RFs fs;

  2515 	User::LeaveIfError(fs.Connect());

  2516 	CleanupClosePushL(fs);

  2517 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2518 	CleanupDeletePushL(source);

  2519 	source->SourcePrimeL();

  2521 	RandomiseBuffer();

  2522 	source->ReadBufferL(iBuffer, iPosition);

  2523 	CleanupStack::PopAndDestroy(2, &fs); //source, fs

  2525 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2526 	TInt readLength = buffer->BufferSize();

  2527 	if (readLength != iReadLength)

  2528 		return EFail;

  2530 	TInt err = CheckBuffer();

  2531 	return (err == 0) ? EPass : EFail;

  2532 	}

  2534 TVerdict TFileReadBuffer4TestStep::DoTestStepL()

  2535 	{

  2536 	RFs fs;

  2537 	User::LeaveIfError(fs.Connect());

  2538 	CleanupClosePushL(fs);

  2539 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2540 	CleanupDeletePushL(source);

  2542 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2543 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2544 	source->SourcePrimeL();

  2546 	RandomiseBuffer();

  2547 	TRAPD(err, source->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  2548 	if (iAsynchronousRead && (err == KErrNone))

  2549 		CActiveScheduler::Start();

  2550 	CleanupStack::PopAndDestroy(2, &fs); //source, fs

  2552 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2553 	if ((err != KErrNone) && sinkBufferFilledOk)

  2554 		return EFail;

  2556 	if (err != KErrNone)

  2557 		User::Leave(err);

  2559 	if (!sinkBufferFilledOk)

  2560 		{

  2561 		if ((err = dummySink->Error()) != KErrNone)

  2562 			User::Leave(err);

  2564 		return EFail;

  2565 		}

  2567 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2568 	TInt readLength = buffer->BufferSize();

  2569 	if (readLength != iExpectedReadLength)

  2570 		return EFail;

  2572 	err = CheckBuffer();

  2573 	return (err == 0) ? EPass : EFail;

  2574 	}

  2576 TVerdict TFileReadBuffer5TestStep::DoTestStepL()

  2577 	{

  2578 	RFs fs;

  2579 	User::LeaveIfError(fs.Connect());

  2580 	CleanupClosePushL(fs);

  2581 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2582 	CleanupDeletePushL(source);

  2584 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2585 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2586 	source->SourcePrimeL();

  2588 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2589 	TInt maxRequestCount = bufferArray.Count();

  2590 	TInt err = KErrNone;

  2591 	iPosition = 0;

  2592 	TInt requestCount;

  2593 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2594 		{

  2595 		iBuffer = bufferArray[requestCount];

  2596 		RandomiseBuffer();

  2598 		TRAP(err, source->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  2599 		if (err != KErrNone)

  2600 			break;

  2602 		iPosition += 2*KTestBufferSize;

  2603 		}

  2605 	if (requestCount)

  2606 		{

  2607 		if (requestCount>iMaxRequestCount)

  2608 			requestCount = iMaxRequestCount;

  2610 		dummySink->SetExpectedFillCount(requestCount);

  2611 		CActiveScheduler::Start();

  2612 		}

  2614 	CleanupStack::PopAndDestroy(2, &fs); // source, fs

  2615 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2616 	if (!requestCount && sinkBufferFilledOk)

  2617 		return EFail;

  2619 	if (!sinkBufferFilledOk && requestCount)

  2620 		{

  2621 		if ((err = dummySink->Error()) != KErrNone)

  2622 			User::Leave(err);

  2624 		return EFail;

  2625 		}

  2627 	iPosition = 0;

  2629 	TInt completionCount;

  2630 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2631 		{

  2632 		iBuffer = bufferArray[completionCount];

  2633 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2634 		TInt readLength = buffer->BufferSize();

  2635 		if (readLength != iReadLength)

  2636 			return EFail;

  2638 		err = CheckBuffer();

  2639 		iPosition += 2*KTestBufferSize;

  2640 		if (err != 0)

  2641 			return EFail;

  2642 		}

  2644 	if (err != KErrNone)

  2645 		User::Leave(err);

  2647 	return EPass;

  2648 	}

  2650 TVerdict TFileReadBuffer6TestStep::DoTestStepL()

  2651 	{

  2652 	RFs fs;

  2653 	User::LeaveIfError(fs.Connect());

  2654 	CleanupClosePushL(fs);

  2655 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, fs, iFileName));

  2656 	CleanupDeletePushL(source);

  2658 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2659 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  2660 	source->SourcePrimeL();

  2662 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2663 	TInt maxRequestCount = bufferArray.Count();

  2664 	TInt err = KErrNone;

  2665 	iPosition = 0;

  2666 	TInt requestCount;

  2667 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2668 		{

  2669 		iBuffer = bufferArray[requestCount];

  2670 		RandomiseBuffer();

  2672 		TRAP(err, source->ReadBufferL(iBuffer, iPosition, iSink));

  2673 		if (err != KErrNone)

  2674 			break;

  2676 		iPosition += 2*KTestBufferSize;

  2677 		}

  2679 	if (requestCount)

  2680 		{

  2681 		if (requestCount>iMaxRequestCount)

  2682 			requestCount = iMaxRequestCount;

  2684 		dummySink->SetExpectedFillCount(requestCount);

  2685 		CActiveScheduler::Start();

  2686 		}

  2688 	CleanupStack::PopAndDestroy(2, &fs); // source, fs

  2689 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2690 	if (!requestCount && sinkBufferFilledOk)

  2691 		return EFail;

  2693 	if (!sinkBufferFilledOk && requestCount)

  2694 		{

  2695 		if ((err = dummySink->Error()) != KErrNone)

  2696 			User::Leave(err);

  2698 		return EFail;

  2699 		}

  2701 	iPosition = 0;

  2703 	TInt completionCount;

  2704 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2705 		{

  2706 		iBuffer = bufferArray[completionCount];

  2707 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2708 		TInt readLength = buffer->BufferSize();

  2709 		if (readLength != iReadLength)

  2710 			return EFail;

  2712 		err = CheckBuffer();

  2713 		iPosition += 2*KTestBufferSize;

  2714 		if (err != 0)

  2715 			return EFail;

  2716 		}

  2718 	if (err != KErrNone)

  2719 		User::Leave(err);

  2721 	return EPass;

  2722 	}

  2724 TVerdict TFileReadBuffer7TestStep::DoTestStepL()

  2725 	{

  2726 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  2728 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2729 	TInt maxRequestCount = bufferArray.Count();

  2730 	TInt err = KErrNone;

  2731 	iPosition = 0;

  2733 	TInt requestCount;

  2734 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2735 		{

  2736 		iBuffer = bufferArray[requestCount];

  2737 		RandomiseBuffer();

  2739 		TRAP(err, clip->ReadBufferL(iReadLength, iBuffer, iPosition, iSink));

  2740 		if (err != KErrNone)

  2741 			break;

  2743 		iPosition += 2*KTestBufferSize;

  2744 		}

  2746 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2747 	if (requestCount)

  2748 		{

  2749 		if (requestCount>iMaxRequestCount)

  2750 			requestCount = iMaxRequestCount;

  2752 		dummySink->SetExpectedFillCount(requestCount);

  2753 		CActiveScheduler::Start();

  2754 		}

  2756 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2757 	if (!requestCount && sinkBufferFilledOk)

  2758 		return EFail;

  2760 	if (!sinkBufferFilledOk && requestCount)

  2761 		{

  2762 		if ((err = dummySink->Error()) != KErrNone)

  2763 			User::Leave(err);

  2765 		return EFail;

  2766 		}

  2768 	iPosition = 0;

  2770 	TInt completionCount;

  2771 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2772 		{

  2773 		iBuffer = bufferArray[completionCount];

  2774 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2775 		TInt readLength = buffer->BufferSize();

  2776 		if (readLength != iReadLength)

  2777 			return EFail;

  2779 		err = CheckBuffer();

  2780 		iPosition += 2*KTestBufferSize;

  2781 		if (err != 0)

  2782 			return EFail;

  2783 		}

  2785 	if (err != KErrNone)

  2786 		User::Leave(err);

  2788 	clip->ReadBufferL(iReadLength, bufferArray[completionCount], iPosition, iSink);

  2789 	return EPass;

  2790 	}

  2792 TVerdict TFileReadBuffer8TestStep::DoTestStepL()

  2793 	{

  2794 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSource);

  2796 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  2797 	TInt maxRequestCount = bufferArray.Count();

  2798 	TInt err = KErrNone;

  2799 	iPosition = 0;

  2801 	TInt requestCount;

  2802 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  2803 		{

  2804 		iBuffer = bufferArray[requestCount];

  2805 		RandomiseBuffer();

  2807 		TRAP(err, clip->ReadBufferL(iBuffer, iPosition, iSink));

  2808 		if (err != KErrNone)

  2809 			break;

  2811 		iPosition += 2*KTestBufferSize;

  2812 		}

  2814 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  2815 	if (requestCount)

  2816 		{

  2817 		if (requestCount>iMaxRequestCount)

  2818 			requestCount = iMaxRequestCount;

  2820 		dummySink->SetExpectedFillCount(requestCount);

  2821 		CActiveScheduler::Start();

  2822 		}

  2824 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  2825 	if (!requestCount && sinkBufferFilledOk)

  2826 		return EFail;

  2828 	if (!sinkBufferFilledOk && requestCount)

  2829 		{

  2830 		if ((err = dummySink->Error()) != KErrNone)

  2831 			User::Leave(err);

  2833 		return EFail;

  2834 		}

  2836 	iPosition = 0;

  2838 	TInt completionCount;

  2839 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  2840 		{

  2841 		iBuffer = bufferArray[completionCount];

  2842 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  2843 		TInt readLength = buffer->BufferSize();

  2844 		if (readLength != iReadLength)

  2845 			return EFail;

  2847 		err = CheckBuffer();

  2848 		iPosition += 2*KTestBufferSize;

  2849 		if (err != 0)

  2850 			return EFail;

  2851 		}

  2853 	if (err != KErrNone)

  2854 		User::Leave(err);

  2856 	clip->ReadBufferL(bufferArray[completionCount], iPosition, iSink);

  2857 	return EPass;

  2858 	}

  2861 TVerdict TNewFileSinkTestStep::DoTestStepL()

  2862 	{

  2863 	CMMFFile* sink = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(iUid, *iConfigDes));

  2864 	CleanupStack::PushL(sink);

  2865 	sink->SinkPrimeL();

  2867 	CleanupStack::PopAndDestroy(sink);

  2868 	return EPass;

  2869 	}

  2871 TVerdict TFileSinkSetSizeTestStep::DoTestStepL()

  2872 	{

  2873 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  2875 	TInt size;

  2876 	TInt oldSize = clip->Size();

  2878 	TInt newSize = oldSize+1;

  2879 	TInt err = clip->SetSize(newSize);

  2880 	if (iCanSetSize)

  2881 		{

  2882 		if (err != KErrNone)

  2883 			User::Leave(err);

  2885 		if ((size = clip->Size()) != newSize)

  2886 			{

  2887 			if (iFileFailureExpected && (size == 0))

  2888 				User::Leave(KErrFileFail);

  2890 			return EFail;

  2891 			}

  2892 		}

  2893 	else

  2894 		{

  2895 		if (err != KErrNotSupported)

  2896 			{

  2897 			if (err == KErrNone)

  2898 				return EFail;

  2900 			User::Leave(err);

  2901 			}

  2903 		if ((size = clip->Size()) != oldSize)

  2904 			return EFail;

  2905 		}

  2906 	return EPass;

  2907 	}

  2909 TInt TFileSinkThreadLogonThread(TAny* initPtr)

  2910 	{

  2911 	TThreadData &threadData = *REINTERPRET_CAST(TThreadData*, initPtr);

  2912 	CMMFFile* sink = threadData.iFilePtr;

  2913 	MAsyncEventHandler* eventHandler = threadData.iEventHandler;

  2915 	threadData.iErr = KErrNone;

  2917 	threadData.iErr = sink->SinkThreadLogon(*eventHandler);

  2918 	if (threadData.iErr == KErrNone)

  2919 		{

  2920 		threadData.iFileSize = sink->Size();

  2921 		sink->SinkThreadLogoff();

  2922 		}

  2925 	return 0;

  2926 	}

  2928 TVerdict TFileSinkThreadLogonTestStep::DoTestStepL()

  2929 	{

  2930 	TBool failure = EFalse;

  2933 	TThreadData threadData; // Is this going to work on target? (or do we need to package the data and use RThread::ReadL/WriteL?)

  2934 	threadData.iFilePtr = STATIC_CAST(CMMFFile*, iSink);

  2935 	threadData.iEventHandler = iEventHandler;

  2937 	TRequestStatus logonStatus;

  2939 	RThread sinkThread;

  2940 	User::LeaveIfError(sinkThread.Create(_L("TFileSinkThreadLogonThread"), TFileSinkThreadLogonThread, KDefaultStackSize, NULL, &threadData));

  2941 	CleanupClosePushL(sinkThread);

  2943 	sinkThread.Logon(logonStatus);

  2944 	if(logonStatus != KRequestPending)

  2945 		{

  2946 		User::Leave(logonStatus.Int());

  2947 		}

  2948 	sinkThread.Resume();

  2950 	User::WaitForRequest(logonStatus);

  2951 	if(logonStatus != KErrNone)

  2952 		{

  2953 		User::Leave(logonStatus.Int());

  2954 		}

  2956 	if (threadData.iErr != KErrNone)

  2957 		User::Leave(threadData.iErr);

  2959 	if ((threadData.iFileSize != iFileSize))

  2960 		{

  2961 		if (!iFileFailureExpected)

  2962 			{

  2963 			failure = ETrue;

  2964 			}

  2966 		if (threadData.iFileSize != 0)

  2967 			{

  2968 			failure = ETrue;

  2969 			}

  2970 		}

  2972 	CleanupStack::PopAndDestroy(1); // sinkThread

  2973 	return (failure ? EFail : EPass);

  2974 	}

  2976 TVerdict TFileEmptyBufferTestStep::DoTestStepL()

  2977 	{

  2978 	RandomiseBuffer();

  2980 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  2981 	User::LeaveIfError(iSink->SinkThreadLogon(*dummySource));

  2982 	iSink->SinkPrimeL();

  2984 	TMediaId mediaId;

  2985 	TRAPD(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  2986 	if (iAsynchronousWrite && (err == KErrNone))

  2987 		{

  2988 		CActiveScheduler::Start();

  2989 		}

  2991 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  2992 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  2993 		return EFail;

  2995 	User::LeaveIfError(err);

  2996 	if (!sourceBufferEmptiedOk)

  2997 		{

  2998 		User::LeaveIfError(dummySource->Error());

  2999 		return EFail;

  3000 		}

  3002 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3003 	TInt writeLength = buffer->BufferSize();

  3004 	if (writeLength != iWriteLength)

  3005 		return EFail;

  3007 	if (iCopyOfDestinationDes.Length()<(iPosition+iWriteLength))

  3008 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3010 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  3011 	iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3012 	return EPass;

  3013 	}

  3015 TVerdict TWriteBufferTestStep::DoTestPostambleL(TBool aCheck)

  3016 	{

  3017 	if (iSink != NULL)

  3018 		iSink->SinkStopL();

  3020 	if (aCheck)

  3021 		{

  3022 		TInt err = CheckDestinationL();

  3023 		return (err == 0) ? EPass : EFail;

  3024 		}

  3026 	return EPass;

  3027 	}

  3029 TVerdict TFileEmptyBuffer2TestStep::DoTestStepL()

  3030 	{

  3031 	TMediaId mediaId;

  3032 	MDataSink* sink = CreateFileSinkL(iSinkType, iFsSession, iDestinationFileName);

  3033 	CleanupDeletePushL(sink);

  3035 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3036 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  3037 	sink->SinkPrimeL();

  3039 	RandomiseBuffer();

  3040 	TRAPD(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  3041 	if (iAsynchronousWrite && (err == KErrNone))

  3042 		{

  3043 		CActiveScheduler::Start();

  3044 		}

  3046 	CleanupStack::PopAndDestroy(sink);

  3048 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3049 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  3050 		{

  3051 		return EFail;

  3052 		}

  3054 	User::LeaveIfError(err);

  3055 	if (!sourceBufferEmptiedOk)

  3056 		{

  3057 		User::LeaveIfError(dummySource->Error());

  3058 		return EFail;

  3059 		}

  3061 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3062 	TInt writeLength = buffer->BufferSize();

  3063 	if (writeLength != iWriteLength)

  3064 		{

  3065 		return EFail;

  3066 		}

  3068 	if (iCopyOfDestinationDes.Length()<(iPosition+iWriteLength))

  3069 		{

  3070 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3071 		}

  3073 	TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  3074 	iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3075 	return EPass;

  3076 	}

  3078 void TFileEmptyBuffer3TestStep::DoTestPreambleL()

  3079 	{

  3080 	CMMFClip* sink = STATIC_CAST(CMMFClip*, CreateFileSinkL(iSinkType, iFsSession, iDestinationFileName ));

  3081 	CleanupDeletePushL(sink);

  3083 	TInt err = sink->Delete();

  3084 	if ((err != KErrNone) && (err != KErrNotFound))

  3085 		{

  3086 		User::Leave(err);

  3087 		}

  3089 	iCopyOfDestinationDes.SetLength(0);

  3090 	CleanupStack::PopAndDestroy(sink);

  3091 	}

  3093 TVerdict TFileEmptyBuffer3TestStep::DoTestStepL()

  3094 	{

  3095 	TMediaId mediaId;

  3096 	CMMFClip* sink = STATIC_CAST(CMMFClip*, CreateFileSinkL(iSinkType, iFsSession, iDestinationFileName));

  3097 	CleanupDeletePushL(sink);

  3099 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3100 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  3101 	sink->SinkPrimeL();

  3103 	TInt totalWriteLength = 0;

  3104 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3105 	TInt maxWriteLength = iCopyOfDestinationDes.MaxLength();

  3106 	TBool failure = EFalse;

  3108 	do

  3109 		{

  3110 		RandomiseBuffer();

  3112 		buffer->Data().SetLength(Min(iWriteLength, maxWriteLength - totalWriteLength));

  3113 		TRAPD(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  3114 		if (iAsynchronousWrite && (err == KErrNone))

  3115 			{

  3116 			CActiveScheduler::Start();

  3117 			}

  3119 		TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3120 		if ((err != KErrNone) && sourceBufferEmptiedOk)

  3121 			{

  3122 			failure = ETrue;

  3123 			break;

  3124 			}

  3126 		User::LeaveIfError(err);

  3128 		if (!sourceBufferEmptiedOk)

  3129 			{

  3130 			User::LeaveIfError(dummySource->Error());

  3131 			failure = ETrue;

  3132 			break;

  3133 			}

  3135 		totalWriteLength += buffer->BufferSize();

  3136 		iCopyOfDestinationDes.Append(buffer->Data());

  3137 		}

  3138 	while (totalWriteLength < maxWriteLength);

  3140 	CleanupStack::PopAndDestroy(sink);

  3141 	return (failure ? EFail : EPass);

  3142 	}

  3144 TVerdict TFileEmptyBuffer3TestStep::DoTestPostambleL(TBool aCheck)

  3145 	{

  3146 	// Close ECom

  3147 	TVerdict verdict = TFileTestStep::DoTestPostambleL(aCheck);

  3148 	if (verdict != EPass)

  3149 		{

  3150 		return verdict;

  3151 		}

  3153 	// Reset the buffer.

  3154 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3155 	buffer->Data().SetLength(iWriteLength);

  3157 	if (aCheck)

  3158 		{

  3159 		TInt err = CheckDestinationL();

  3160 		return (err == 0) ? EPass : EFail;

  3161 		}

  3163 	return EPass;

  3164 	}

  3166 void TFileEmptyBuffer4TestStep::DoTestPreambleL()

  3167 	{

  3168 	TWriteBufferToFileTestStep::DoTestPreambleL();

  3169 	}

  3171 TVerdict TFileEmptyBuffer4TestStep::DoTestStepL()

  3172 	{

  3173 	TMediaId mediaId;

  3174 	CMMFClip* sink = STATIC_CAST(CMMFClip*, CreateFileSinkL(iSinkType, iFsSession, iDestinationFileName));

  3175 	CleanupDeletePushL(sink);

  3177 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3178 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  3179 	sink->SinkPrimeL();

  3181 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3182 	TInt maxRequestCount = Min(iMaxRequestCount, bufferArray.Count());

  3183 	TInt err = KErrNone;

  3184 	iPosition = 0;

  3186 	// For each buffer in the array try to empty it. Stop at the first failure.

  3187 	// The test step should not Leave if there is an error as this will cause

  3188 	// the CheckDestinationL function to fail... all successful empties must

  3189 	// be completed.

  3190 	TInt requestCount;

  3191 	for (requestCount = 0; requestCount < maxRequestCount; requestCount++)

  3192 		{

  3193 		iBuffer = bufferArray[requestCount];

  3194 		RandomiseBuffer();

  3196 		TRAP(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  3197 		if (err != KErrNone)

  3198 			{

  3199 			break;

  3200 			}

  3201 		}

  3203 	if (requestCount)

  3204 		{

  3205 		dummySource->SetExpectedEmptyCount(requestCount);

  3206 		CActiveScheduler::Start();

  3207 		}

  3209 	CleanupStack::PopAndDestroy(sink);

  3211 	if (dummySource->ErrorCount())

  3212 		{

  3213 		User::LeaveIfError(dummySource->Error());

  3214 		}

  3216 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3217 	if (!requestCount && sourceBufferEmptiedOk)

  3218 		{

  3219 		return EFail;

  3220 		}

  3222 	TInt completionCount;

  3223 	for (completionCount = 0; completionCount < requestCount; completionCount++)

  3224 		{

  3225 		iBuffer = bufferArray[completionCount];

  3226 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3227 		TInt writeLength = buffer->BufferSize();

  3228 		if (writeLength != iWriteLength)

  3229 			{

  3230 			return EFail;

  3231 			}

  3233 		if ((iPosition + iWriteLength) > iCopyOfDestinationDes.Length())

  3234 			iCopyOfDestinationDes.SetLength(iPosition + iWriteLength);

  3236 		TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  3237 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3238 		iPosition += iWriteLength;

  3239 		}

  3241 	return EPass;

  3242 	}

  3244 TVerdict TFileEmptyBuffer4TestStep::DoTestPostambleL(TBool aCheck)

  3245 	{

  3246 	// Close ECom

  3247 	TVerdict verdict = TFileTestStep::DoTestPostambleL(aCheck);

  3248 	if (verdict != EPass)

  3249 		{

  3250 		return verdict;

  3251 		}

  3253 	if (aCheck)

  3254 		{

  3255 		TInt err = CheckDestinationL();

  3256 		return (err == 0) ? EPass : EFail;

  3257 		}

  3259 	return EPass;

  3260 	}

  3262 TInt TFileEmptyBuffer5TestStep::CheckDestinationL()

  3263 	{

  3264 	TInt length = iCopyOfDestinationDes.Length();

  3266 	// Read the file into a descriptor.

  3267 	RFile destinationFile;

  3268 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead | EFileShareAny);

  3269 	CleanupClosePushL(destinationFile);

  3270 	if (err != KErrNone)

  3271 		{

  3272 		CleanupStack::PopAndDestroy(&destinationFile);

  3274 		if (err == KErrNotFound)

  3275 			return (length != 0) ? -1 : 0;

  3277 		User::Leave(err);

  3278 		}

  3280 	TInt destinationFileSize;

  3281 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  3283 	// Check that the file length is correct.

  3284 	if (destinationFileSize != length)

  3285 		{

  3286 		CleanupStack::PopAndDestroy(&destinationFile);

  3287 		return -1;

  3288 		}

  3290 	HBufC8* destinationHBuf = HBufC8::NewLC(destinationFileSize);

  3291 	TPtr8 destinationDes = destinationHBuf->Des();

  3292 	User::LeaveIfError(destinationFile.Read(destinationDes));

  3294 	// Check that the file data matches.

  3295 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3296 	if (err != 0)

  3297 		{

  3298 		// At least one of the remaining two writes was completed.

  3299 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3300 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  3301 		TInt writeLength = buffer->BufferSize();

  3302 		if (writeLength != iWriteLength)

  3303 			return EFail;

  3305 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3306 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3307 		err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3308 		if (err != 0)

  3309 			{

  3310 			iPosition += iWriteLength;

  3312 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  3313 			writeLength = buffer->BufferSize();

  3314 			if (writeLength != iWriteLength)

  3315 				return EFail;

  3317 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  3318 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3320 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3321 			}

  3322 		}

  3324 	CleanupStack::PopAndDestroy(destinationHBuf);

  3325 	CleanupStack::PopAndDestroy(&destinationFile);

  3326 	return err;

  3327 	}

  3329 TVerdict TFileEmptyBuffer6TestStep::DoTestStepL()

  3330 	{

  3331 	TMediaId mediaId;

  3332 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3333 	TInt maxRequestCount = bufferArray.Count();

  3334 	TInt err = KErrNone;

  3335 	iPosition = 0;

  3337 	TInt requestCount;

  3338 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  3339 		{

  3340 		iBuffer = bufferArray[requestCount];

  3341 		RandomiseBuffer();

  3343 		TRAP(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  3344 		if (err != KErrNone)

  3345 			break;

  3346 		}

  3348 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3349 	if (requestCount)

  3350 		{

  3351 		if (requestCount>iMaxRequestCount)

  3352 			requestCount = iMaxRequestCount;

  3354 		dummySource->SetExpectedEmptyCount(requestCount);

  3355 		CActiveScheduler::Start();

  3356 		}

  3358 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3359 	if (!requestCount && sourceBufferEmptiedOk)

  3360 		return EFail;

  3362 	if (!sourceBufferEmptiedOk && requestCount)

  3363 		{

  3364 		requestCount-= dummySource->ErrorCount();

  3365 		err = dummySource->Error();

  3367 		if (err == KErrNone)

  3368 			return EFail;

  3369 		}

  3371 	TInt completionCount;

  3372 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  3373 		{

  3374 		iBuffer = bufferArray[completionCount];

  3376 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3377 		TInt writeLength = buffer->BufferSize();

  3378 		if (writeLength != iWriteLength)

  3379 			return EFail;

  3381 		if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  3382 			iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3384 		TPtrC8 bufferData(buffer->Data().Ptr(), iWriteLength);

  3385 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3386 		iPosition += iWriteLength;

  3387 		}

  3389 	if (err != KErrNone)

  3390 		User::Leave(err);

  3392 	iSink->EmptyBufferL(bufferArray[0], iSource, mediaId);

  3393 	return EPass;

  3394 	}

  3396 TInt TFileEmptyBuffer6TestStep::CheckDestinationL()

  3397 	{

  3398 	TInt length = iCopyOfDestinationDes.Length();

  3400 	// Read the file into a descriptor.

  3401 	RFile destinationFile;

  3402 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead | EFileShareAny);

  3403 	CleanupClosePushL(destinationFile);

  3404 	if (err != KErrNone)

  3405 		{

  3406 		CleanupStack::PopAndDestroy(&destinationFile);

  3408 		if (err == KErrNotFound)

  3409 			return (length != 0) ? -1 : 0;

  3411 		User::Leave(err);

  3412 		}

  3414 	TInt destinationFileSize;

  3415 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  3417 	// Check that the file length is correct.

  3418 	if (destinationFileSize != length)

  3419 		{

  3420 		if (destinationFileSize != (length+iWriteLength))

  3421 			{

  3422 			if (destinationFileSize != (length+2*iWriteLength))

  3423 				{

  3424 				if (destinationFileSize != (length+3*iWriteLength))

  3425 					{

  3426 					CleanupStack::PopAndDestroy(&destinationFile);

  3427 					return -1;

  3428 					}

  3429 				}

  3430 			}

  3431 		}

  3433 	HBufC8* destinationHBuf = HBufC8::NewLC(destinationFileSize);

  3434 	TPtr8 destinationDes = destinationHBuf->Des();

  3435 	User::LeaveIfError(destinationFile.Read(destinationDes));

  3437 	// Check that the file data matches.

  3438 	err = Mem::Compare(destinationDes.Ptr(), destinationFileSize, iCopyOfDestinationDes.Ptr(), length);

  3439 	if (err != 0)

  3440 		{

  3441 		// At least one of the remaining three writes was completed.

  3442 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3443 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  3444 		TInt writeLength = buffer->BufferSize();

  3445 		if (writeLength != iWriteLength)

  3446 			return EFail;

  3448 		if ((iPosition+iWriteLength)<=iCopyOfDestinationDes.Length())

  3449 			return EFail;

  3450 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3451 		length = iPosition+iWriteLength;

  3453 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3454 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3455 		err = Mem::Compare(destinationDes.Ptr(), destinationFileSize, iCopyOfDestinationDes.Ptr(), length);

  3456 		if (err != 0)

  3457 			{

  3458 			iPosition += iWriteLength;

  3460 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  3461 			writeLength = buffer->BufferSize();

  3462 			if (writeLength != iWriteLength)

  3463 				return EFail;

  3465 			if ((iPosition+iWriteLength)<=iCopyOfDestinationDes.Length())

  3466 				return EFail;

  3467 			iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3468 			length = iPosition+iWriteLength;

  3470 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  3471 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3473 			err = Mem::Compare(destinationDes.Ptr(), destinationFileSize, iCopyOfDestinationDes.Ptr(), length);

  3474 			if (err != 0)

  3475 				{

  3476 				iPosition += iWriteLength;

  3477 				if ((iPosition+iWriteLength)<=iCopyOfDestinationDes.Length())

  3478 					return EFail;

  3479 				iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3480 				length = iPosition+iWriteLength;

  3482 				buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[0]);

  3483 				bufferData.Set(buffer->Data().Ptr(), iWriteLength);

  3485 				iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3486 				err = Mem::Compare(destinationDes.Ptr(), destinationFileSize, iCopyOfDestinationDes.Ptr(), length);

  3487 				}

  3488 			}

  3489 		}

  3491 	CleanupStack::PopAndDestroy(destinationHBuf);

  3492 	CleanupStack::PopAndDestroy(&destinationFile);

  3493 	return err;

  3494 	}

  3496 TVerdict TFileWriteBufferTestStep::DoTestStepL()

  3497 	{

  3498 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  3500 	RandomiseBuffer();

  3501 	TRAPD(err, clip->WriteBufferL(iWriteLength, iBuffer, iPosition, iSource));

  3502 	if (err == KErrNone)

  3503 		CActiveScheduler::Start();

  3505 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3506 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3507 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  3508 		return EFail;

  3510 	if (err != KErrNone)

  3511 		User::Leave(err);

  3513 	if (!sourceBufferEmptiedOk)

  3514 		{

  3515 		if ((err = dummySource->Error()) != KErrNone)

  3516 			User::Leave(err);

  3518 		return EFail;

  3519 		}

  3521 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3522 	if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  3523 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3525 	iCopyOfDestinationDes.Replace(iPosition, iWriteLength, buffer->Data());

  3526 	return EPass;

  3527 	}

  3529 TVerdict TFileWriteBuffer2TestStep::DoTestStepL()

  3530 	{

  3531 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  3533 	RandomiseBuffer();

  3534 	TRAPD(err, clip->WriteBufferL(iBuffer, iPosition, iSource));

  3535 	if (err == KErrNone)

  3536 		CActiveScheduler::Start();

  3538 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3539 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3540 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  3541 		return EFail;

  3543 	if (err != KErrNone)

  3544 		User::Leave(err);

  3546 	if (!sourceBufferEmptiedOk)

  3547 		{

  3548 		if ((err = dummySource->Error()) != KErrNone)

  3549 			User::Leave(err);

  3551 		return EFail;

  3552 		}

  3554 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3555 	if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  3556 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3558 	iCopyOfDestinationDes.Replace(iPosition, iWriteLength, buffer->Data());

  3559 	return EPass;

  3560 	}

  3562 TVerdict TFileWriteBuffer3TestStep::DoTestStepL()

  3563 	{

  3564 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  3566 	RandomiseBuffer();

  3567 	clip->WriteBufferL(iBuffer, iPosition);

  3569 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3570 	if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  3571 		iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  3573 	iCopyOfDestinationDes.Replace(iPosition, buffer->BufferSize(), buffer->Data());

  3574 	return EPass;

  3575 	}

  3577 TVerdict TFileWriteBuffer4TestStep::DoTestStepL()

  3578 	{

  3579 	RFs fs;

  3580 	User::LeaveIfError(fs.Connect());

  3581 	CleanupClosePushL(fs);

  3582 	CMMFClip* clip = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, fs, iFileName));

  3583 	CleanupDeletePushL(clip);

  3585 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3586 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  3587 	clip->SinkPrimeL();

  3589 	RandomiseBuffer();

  3590 	TRAPD(err, clip->WriteBufferL(iWriteLength, iBuffer, iPosition, iSource));

  3591 	if (err == KErrNone)

  3592 		CActiveScheduler::Start();

  3593 	CleanupStack::PopAndDestroy(2, &fs); // clip, fs

  3595 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3596 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  3597 		return EFail;

  3599 	if (err != KErrNone)

  3600 		User::Leave(err);

  3602 	if (!sourceBufferEmptiedOk)

  3603 		{

  3604 		if ((err = dummySource->Error()) != KErrNone)

  3605 			User::Leave(err);

  3607 		return EFail;

  3608 		}

  3610 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3611 	TInt writeLength = iWriteLength;

  3612 	if (writeLength>buffer->Data().Length())

  3613 		writeLength = buffer->Data().Length();

  3615 	TInt position = iPosition;

  3616 	if (position>iCopyOfDestinationDes.Length())

  3617 		position = iCopyOfDestinationDes.Length();

  3619 	if ((position+writeLength)>iCopyOfDestinationDes.Length())

  3620 		iCopyOfDestinationDes.SetLength(position+writeLength);

  3622 	TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3623 	iCopyOfDestinationDes.Replace(position, writeLength, bufferData);

  3624 	return EPass;

  3625 	}

  3627 TInt TFileWriteBuffer5TestStep::CheckDestinationL()

  3628 	{

  3629 	TInt length = iCopyOfDestinationDes.Length();

  3631 	// Read the file into a descriptor.

  3632 	RFile destinationFile;

  3633 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead | EFileShareAny);

  3634 	CleanupClosePushL(destinationFile);

  3635 	if (err != KErrNone)

  3636 		{

  3637 		CleanupStack::PopAndDestroy(&destinationFile);

  3639 		if (err == KErrNotFound)

  3640 			return (length != 0) ? -1 : 0;

  3642 		User::Leave(err);

  3643 		}

  3645 	TInt destinationFileSize;

  3646 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  3648 	// Check that the file length is correct.

  3649 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3650 	if (destinationFileSize != (length+(iWriteLength-buffer->Data().Length())))

  3651 		{

  3652 		CleanupStack::PopAndDestroy(&destinationFile);

  3653 		return -1;

  3654 		}

  3656 	HBufC8* destinationHBuf = HBufC8::NewLC(destinationFileSize);

  3657 	TPtr8 destinationDes = destinationHBuf->Des();

  3658 	User::LeaveIfError(destinationFile.Read(destinationDes));

  3660 	// Check that the file data matches.

  3661 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3663 	// Copy the file.

  3664 	iCopyOfDestinationDes.Copy(destinationDes);

  3666 	CleanupStack::PopAndDestroy(destinationHBuf);

  3667 	CleanupStack::PopAndDestroy(&destinationFile);

  3668 	return err;

  3669 	}

  3671 TVerdict TFileWriteBuffer5TestStep::DoNegativeTestPostambleL()

  3672 	{

  3673 	TInt length = iCopyOfDestinationDes.Length();

  3675 	// Read the file into a descriptor.

  3676 	RFile destinationFile;

  3677 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead);

  3678 	CleanupClosePushL(destinationFile);

  3679 	if (err != KErrNone)

  3680 		{

  3681 		CleanupStack::PopAndDestroy(&destinationFile);

  3683 		if (err == KErrNotFound)

  3684 			return (length == 0) ? EPass : EFail;

  3686 		User::Leave(err);

  3687 		}

  3689 	TInt destinationFileSize;

  3690 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  3692 	// Check that the file length is correct.

  3693 	if (destinationFileSize != length)

  3694 		{

  3695 		CleanupStack::PopAndDestroy(&destinationFile);

  3696 		return EFail;

  3697 		}

  3699 	HBufC8* destinationHBuf = HBufC8::NewLC(length);

  3700 	TPtr8 destinationDes = destinationHBuf->Des();

  3701 	User::LeaveIfError(destinationFile.Read(destinationDes));

  3703 	// Check that the file data matches.

  3704 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3706 	CleanupStack::PopAndDestroy(destinationHBuf);

  3707 	CleanupStack::PopAndDestroy(&destinationFile);

  3708 	return (err == 0) ? EPass : EFail;

  3709 	}

  3711 TVerdict TFileWriteBuffer6TestStep::DoTestStepL()

  3712 	{

  3713 	RFs fs;

  3714 	User::LeaveIfError(fs.Connect());

  3715 	CleanupClosePushL(fs);

  3716 	CMMFClip* clip = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, fs, iFileName));

  3717 	CleanupDeletePushL(clip);

  3719 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3720 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  3721 	clip->SinkPrimeL();

  3723 	RandomiseBuffer();

  3724 	TRAPD(err, clip->WriteBufferL(iBuffer, iPosition, iSource));

  3725 	if (err == KErrNone)

  3726 		CActiveScheduler::Start();

  3727 	CleanupStack::PopAndDestroy(2, &fs); // clip, fs

  3729 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3730 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  3731 		return EFail;

  3733 	if (err != KErrNone)

  3734 		User::Leave(err);

  3736 	if (!sourceBufferEmptiedOk)

  3737 		{

  3738 		if ((err = dummySource->Error()) != KErrNone)

  3739 			User::Leave(err);

  3741 		return EFail;

  3742 		}

  3744 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3745 	TInt position = iPosition;

  3746 	TInt bufferSize = buffer->BufferSize();

  3747 	if (position>iCopyOfDestinationDes.Length())

  3748 		position = iCopyOfDestinationDes.Length();

  3750 	if ((position+bufferSize)>iCopyOfDestinationDes.Length())

  3751 		iCopyOfDestinationDes.SetLength(position+bufferSize);

  3753 	iCopyOfDestinationDes.Replace(position, bufferSize, buffer->Data());

  3754 	return EPass;

  3755 	}

  3757 TVerdict TFileWriteBuffer7TestStep::DoTestStepL()

  3758 	{

  3759 	RFs fs;

  3760 	User::LeaveIfError(fs.Connect());

  3761 	CleanupClosePushL(fs);

  3762 	CMMFClip* clip = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, fs, iFileName));

  3763 	CleanupDeletePushL(clip);

  3765 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3766 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  3767 	clip->SinkPrimeL();

  3769 	RandomiseBuffer();

  3770 	clip->WriteBufferL(iBuffer, iPosition);

  3771 	CleanupStack::PopAndDestroy(2, &fs);

  3773 	CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3774 	TInt position = iPosition;

  3775 	TInt bufferSize = buffer->BufferSize();

  3776 	if (position>iCopyOfDestinationDes.Length())

  3777 		position = iCopyOfDestinationDes.Length();

  3779 	if ((position+bufferSize)>iCopyOfDestinationDes.Length())

  3780 		iCopyOfDestinationDes.SetLength(position+bufferSize);

  3782 	iCopyOfDestinationDes.Replace(position, bufferSize, buffer->Data());

  3783 	return EPass;

  3784 	}

  3786 TVerdict TFileWriteBuffer8TestStep::DoTestStepL()

  3787 	{

  3788 	RFs fs;

  3789 	User::LeaveIfError(fs.Connect());

  3790 	CleanupClosePushL(fs);

  3791 	CMMFClip* clip = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, fs, iFileName));

  3792 	CleanupDeletePushL(clip);

  3794 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3795 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  3796 	clip->SinkPrimeL();

  3798 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3799 	TInt maxRequestCount = Min(iMaxRequestCount, bufferArray.Count());

  3800 	iPosition = 0;

  3802 	TInt requestCount;

  3803 	for (requestCount = 0; requestCount < maxRequestCount; requestCount++)

  3804 		{

  3805 		iBuffer = bufferArray[requestCount];

  3806 		RandomiseBuffer();

  3808 		TRAPD(err, clip->WriteBufferL(iWriteLength, iBuffer, iPosition, iSource));

  3809 		if (err != KErrNone)

  3810 			{

  3811 			break;

  3812 			}

  3814 		iPosition += iWriteLength;

  3815 		}

  3817 	if (requestCount)

  3818 		{

  3819 		dummySource->SetExpectedEmptyCount(requestCount);

  3820 		CActiveScheduler::Start();

  3821 		}

  3823 	CleanupStack::PopAndDestroy(2, &fs);

  3825 	if (dummySource->ErrorCount())

  3826 		{

  3827 		User::Leave(dummySource->Error());

  3828 		}

  3830 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3831 	if (!requestCount && sourceBufferEmptiedOk)

  3832 		{

  3833 		return EFail;

  3834 		}

  3836 	iPosition = 0;

  3837 	TInt completionCount;

  3838 	for (completionCount = 0; completionCount < requestCount; completionCount++)

  3839 		{

  3840 		iBuffer = bufferArray[completionCount];

  3841 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3842 		TInt writeLength = buffer->BufferSize();

  3843 		if (writeLength != iWriteLength)

  3844 			{

  3845 			return EFail;

  3846 			}

  3848 		if ((iPosition + iWriteLength) > iCopyOfDestinationDes.Length())

  3849 			{

  3850 			iCopyOfDestinationDes.SetLength(iPosition + iWriteLength);

  3851 			}

  3853 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3854 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3855 		iPosition += writeLength;

  3856 		}

  3858 	return EPass;

  3859 	}

  3861 TVerdict TFileWriteBuffer9TestStep::DoTestStepL()

  3862 	{

  3863 	RFs fs;

  3864 	User::LeaveIfError(fs.Connect());

  3865 	CleanupClosePushL(fs);

  3866 	CMMFClip* clip = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, fs, iFileName));

  3867 	CleanupDeletePushL(clip);

  3869 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  3870 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  3871 	clip->SinkPrimeL();

  3873 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3874 	TInt maxRequestCount = Min(iMaxRequestCount, bufferArray.Count());

  3875 	iPosition = 0;

  3877 	TInt requestCount;

  3878 	for (requestCount = 0; requestCount < maxRequestCount; requestCount++)

  3879 		{

  3880 		iBuffer = bufferArray[requestCount];

  3881 		RandomiseBuffer();

  3883 		TRAPD(err, clip->WriteBufferL(iBuffer, iPosition, iSource));

  3884 		if (err != KErrNone)

  3885 			{

  3886 			break;

  3887 			}

  3889 		iPosition += iWriteLength;

  3890 		}

  3892 	if (requestCount)

  3893 		{

  3894 		dummySource->SetExpectedEmptyCount(requestCount);

  3895 		CActiveScheduler::Start();

  3896 		}

  3898 	CleanupStack::PopAndDestroy(2, &fs);

  3900 	if (dummySource->ErrorCount())

  3901 		{

  3902 		User::LeaveIfError(dummySource->Error());

  3903 		}

  3905 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  3906 	if (!requestCount && sourceBufferEmptiedOk)

  3907 		{

  3908 		return EFail;

  3909 		}

  3911 	iPosition = 0;

  3912 	TInt completionCount;

  3913 	for (completionCount = 0; completionCount < requestCount; completionCount++)

  3914 		{

  3915 		iBuffer = bufferArray[completionCount];

  3916 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  3917 		TInt writeLength = buffer->BufferSize();

  3918 		if (writeLength != iWriteLength)

  3919 			{

  3920 			return EFail;

  3921 			}

  3923 		if ((iPosition + iWriteLength) > iCopyOfDestinationDes.Length())

  3924 			{

  3925 			iCopyOfDestinationDes.SetLength(iPosition + iWriteLength);

  3926 			}

  3928 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3929 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3930 		iPosition += iWriteLength;

  3931 		}

  3933 	return EPass;

  3934 	}

  3936 TInt TFileWriteBuffer10TestStep::CheckDestinationL()

  3937 	{

  3938 	TInt length = iCopyOfDestinationDes.Length();

  3940 	// Read the file into a descriptor.

  3941 	RFile destinationFile;

  3942 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead|EFileShareAny);

  3943 	CleanupClosePushL(destinationFile);

  3944 	if (err != KErrNone)

  3945 		{

  3946 		CleanupStack::PopAndDestroy(&destinationFile);

  3948 		if (err == KErrNotFound)

  3949 			return (length != 0) ? -1 : 0;

  3951 		User::Leave(err);

  3952 		}

  3954 	TInt destinationFileSize;

  3955 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  3957 	// Check that the file length is correct.

  3958 	if (destinationFileSize != length)

  3959 		{

  3960 		CleanupStack::PopAndDestroy(&destinationFile);

  3961 		return -1;

  3962 		}

  3964 	HBufC8* destinationHBuf = HBufC8::NewLC(length);

  3965 	TPtr8 destinationDes = destinationHBuf->Des();

  3966 	User::LeaveIfError(destinationFile.Read(destinationDes));

  3968 	// Check that the file data matches.

  3969 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3970 	if (err != 0)

  3971 		{

  3972 		// At least one of the remaining two writes was completed.

  3973 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  3974 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  3975 		TInt writeLength = buffer->BufferSize();

  3976 		if (writeLength != iWriteLength)

  3977 			return EFail;

  3979 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  3980 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3981 		err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3983 		if (err != 0)

  3984 			{

  3985 			iPosition += iWriteLength;

  3987 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  3988 			writeLength = buffer->BufferSize();

  3989 			if (writeLength != iWriteLength)

  3990 				return EFail;

  3992 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  3993 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  3995 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  3996 			}

  3997 		}

  3999 	CleanupStack::PopAndDestroy(destinationHBuf);

  4000 	CleanupStack::PopAndDestroy(&destinationFile);

  4002 	return err;

  4003 	}

  4005 TInt TFileWriteBuffer11TestStep::CheckDestinationL()

  4006 	{

  4007 	TInt length = iCopyOfDestinationDes.Length();

  4009 	// Read the file into a descriptor.

  4010 	RFile destinationFile;

  4011 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead | EFileShareAny);

  4012 	CleanupClosePushL(destinationFile);

  4013 	if (err != KErrNone)

  4014 		{

  4015 		CleanupStack::PopAndDestroy(&destinationFile);

  4017 		if (err == KErrNotFound)

  4018 			return (length != 0) ? -1 : 0;

  4020 		User::Leave(err);

  4021 		}

  4023 	TInt destinationFileSize;

  4024 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  4026 	// Check that the file length is correct.

  4027 	if (destinationFileSize != length)

  4028 		{

  4029 		CleanupStack::PopAndDestroy(&destinationFile);

  4030 		return -1;

  4031 		}

  4033 	HBufC8* destinationHBuf = HBufC8::NewLC(length);

  4034 	TPtr8 destinationDes = destinationHBuf->Des();

  4035 	User::LeaveIfError(destinationFile.Read(destinationDes));

  4037 	// Check that the file data matches.

  4038 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4039 	if (err != 0)

  4040 		{

  4041 		// At least one of the remaining two writes was completed.

  4042 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  4043 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  4044 		TInt writeLength = buffer->BufferSize();

  4045 		if (writeLength != iWriteLength)

  4046 			return EFail;

  4048 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  4049 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4050 		err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4052 		if (err != 0)

  4053 			{

  4054 			iPosition += iWriteLength;

  4056 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  4057 			writeLength = buffer->BufferSize();

  4058 			if (writeLength != iWriteLength)

  4059 				return EFail;

  4061 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  4062 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4064 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4065 			}

  4066 		}

  4068 	CleanupStack::PopAndDestroy(destinationHBuf);

  4069 	CleanupStack::PopAndDestroy(&destinationFile);

  4071 	return err;

  4072 	}

  4074 TVerdict TFileWriteBuffer12TestStep::DoTestStepL()

  4075 	{

  4076 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  4078 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  4079 	TInt maxRequestCount = bufferArray.Count();

  4080 	TInt err = KErrNone;

  4081 	iPosition = 0;

  4083 	TInt requestCount;

  4084 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  4085 		{

  4086 		iBuffer = bufferArray[requestCount];

  4087 		RandomiseBuffer();

  4089 		TRAPD(err, clip->WriteBufferL(iWriteLength, iBuffer, iPosition, iSource));

  4090 		if (err != KErrNone)

  4091 			break;

  4093 		iPosition += iWriteLength;

  4094 		}

  4096 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4097 	if (requestCount)

  4098 		{

  4099 		if (requestCount>iMaxRequestCount)

  4100 			requestCount = iMaxRequestCount;

  4102 		dummySource->SetExpectedEmptyCount(requestCount);

  4103 		CActiveScheduler::Start();

  4104 		}

  4106 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4107 	if (!requestCount && sourceBufferEmptiedOk)

  4108 		return EFail;

  4110 	if (!sourceBufferEmptiedOk && requestCount)

  4111 		{

  4112 		requestCount-= dummySource->ErrorCount();

  4113 		err = dummySource->Error();

  4115 		if (err == KErrNone)

  4116 			return EFail;

  4117 		}

  4119 	iPosition = 0;

  4120 	TInt completionCount;

  4121 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  4122 		{

  4123 		iBuffer = bufferArray[completionCount];

  4124 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  4125 		TInt writeLength = buffer->BufferSize();

  4126 		if (writeLength != iWriteLength)

  4127 			return EFail;

  4129 		if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  4130 			iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  4132 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  4133 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4134 		iPosition += iWriteLength;

  4135 		}

  4137 	if (err != KErrNone)

  4138 		User::Leave(err);

  4140 	clip->WriteBufferL(iWriteLength, bufferArray[0], iPosition + 2*iWriteLength, iSource);

  4141 	return EPass;

  4142 	}

  4144 TInt TFileWriteBuffer12TestStep::CheckDestinationL()

  4145 	{

  4146 	TInt length = iCopyOfDestinationDes.Length();

  4148 	// Read the file into a descriptor.

  4149 	RFile destinationFile;

  4150 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead |EFileShareAny);

  4151 	CleanupClosePushL(destinationFile);

  4152 	if (err != KErrNone)

  4153 		{

  4154 		CleanupStack::PopAndDestroy(&destinationFile);

  4156 		if (err == KErrNotFound)

  4157 			return (length != 0) ? -1 : 0;

  4159 		User::Leave(err);

  4160 		}

  4162 	TInt destinationFileSize;

  4163 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  4165 	// Check that the file length is correct.

  4166 	if (destinationFileSize != length)

  4167 		{

  4168 		if (destinationFileSize != (length + iWriteLength))

  4169 			{

  4170 			CleanupStack::PopAndDestroy(&destinationFile);

  4171 			return -1;

  4172 			}

  4173 		}

  4175 	HBufC8* destinationHBuf = HBufC8::NewLC(destinationFileSize);

  4176 	TPtr8 destinationDes = destinationHBuf->Des();

  4177 	User::LeaveIfError(destinationFile.Read(destinationDes));

  4179 	// Check that the file data matches.

  4180 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4181 	if (err != 0)

  4182 		{

  4183 		// At least one of the remaining three writes was completed.

  4184 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  4185 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  4186 		TInt writeLength = buffer->BufferSize();

  4187 		if (writeLength != iWriteLength)

  4188 			return EFail;

  4190 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  4191 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4192 		err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4193 		if (err != 0)

  4194 			{

  4195 			iPosition += iWriteLength;

  4197 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  4198 			writeLength = buffer->BufferSize();

  4199 			if (writeLength != iWriteLength)

  4200 				return EFail;

  4202 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  4203 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4205 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4206 			if (err != 0)

  4207 				return EFail;

  4209 			iPosition += iWriteLength;

  4210 			if ((iPosition+iWriteLength)<=iCopyOfDestinationDes.Length())

  4211 				return EFail;

  4212 			iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  4213 			length = iPosition+iWriteLength;

  4215 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[0]);

  4216 			bufferData.Set(buffer->Data().Ptr(), iWriteLength);

  4218 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4219 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4220 			}

  4221 		}

  4223 	CleanupStack::PopAndDestroy(destinationHBuf);

  4224 	CleanupStack::PopAndDestroy(&destinationFile);

  4225 	return err;

  4226 	}

  4228 TVerdict TFileWriteBuffer13TestStep::DoTestStepL()

  4229 	{

  4230 	CMMFClip* clip = STATIC_CAST(CMMFClip*, iSink);

  4232 	RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  4233 	TInt maxRequestCount = bufferArray.Count();

  4234 	TInt err = KErrNone;

  4235 	iPosition = 0;

  4237 	TInt requestCount;

  4238 	for (requestCount = 0 ; requestCount<maxRequestCount ; requestCount++)

  4239 		{

  4240 		iBuffer = bufferArray[requestCount];

  4241 		RandomiseBuffer();

  4243 		TRAPD(err, clip->WriteBufferL(iBuffer, iPosition, iSource));

  4244 		if (err != KErrNone)

  4245 			break;

  4247 		iPosition += iWriteLength;

  4248 		}

  4250 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4251 	if (requestCount)

  4252 		{

  4253 		if (requestCount>iMaxRequestCount)

  4254 			requestCount = iMaxRequestCount;

  4256 		dummySource->SetExpectedEmptyCount(requestCount);

  4257 		CActiveScheduler::Start();

  4258 		}

  4260 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4261 	if (!requestCount && sourceBufferEmptiedOk)

  4262 		return EFail;

  4264 	if (!sourceBufferEmptiedOk && requestCount)

  4265 		{

  4266 		requestCount-= dummySource->ErrorCount();

  4267 		err = dummySource->Error();

  4269 		if (err == KErrNone)

  4270 			return EFail;

  4271 		}

  4273 	iPosition = 0;

  4274 	TInt completionCount;

  4275 	for (completionCount = 0 ; completionCount<requestCount ; completionCount++)

  4276 		{

  4277 		iBuffer = bufferArray[completionCount];

  4278 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, iBuffer);

  4279 		TInt writeLength = buffer->BufferSize();

  4280 		if (writeLength != iWriteLength)

  4281 			return EFail;

  4283 		if ((iPosition+iWriteLength)>iCopyOfDestinationDes.Length())

  4284 			iCopyOfDestinationDes.SetLength(iPosition+iWriteLength);

  4286 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  4287 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4289 		iPosition += iWriteLength;

  4290 		}

  4292 	if (err != KErrNone)

  4293 		User::Leave(err);

  4295 	clip->WriteBufferL(bufferArray[0], iPosition + 2*iWriteLength, iSource);

  4296 	return EPass;

  4297 	}

  4299 TInt TFileWriteBuffer13TestStep::CheckDestinationL()

  4300 	{

  4301 	TInt length = iCopyOfDestinationDes.Length();

  4303 	// Read the file into a descriptor.

  4304 	RFile destinationFile;

  4305 	TInt err = destinationFile.Open(iFsSession, iDestinationFileName, EFileRead | EFileShareAny);

  4306 	CleanupClosePushL(destinationFile);

  4307 	if (err != KErrNone)

  4308 		{

  4309 		CleanupStack::PopAndDestroy(&destinationFile);

  4311 		if (err == KErrNotFound)

  4312 			return (length != 0) ? -1 : 0;

  4314 		User::Leave(err);

  4315 		}

  4317 	TInt destinationFileSize;

  4318 	User::LeaveIfError(destinationFile.Size(destinationFileSize));

  4320 	// Check that the file length is correct.

  4321 	if (destinationFileSize != length)

  4322 		{

  4323 		CleanupStack::PopAndDestroy(&destinationFile);

  4324 		return -1;

  4325 		}

  4327 	HBufC8* destinationHBuf = HBufC8::NewLC(destinationFileSize);

  4328 	TPtr8 destinationDes = destinationHBuf->Des();

  4329 	User::LeaveIfError(destinationFile.Read(destinationDes));

  4331 	// Check that the file data matches.

  4332 	err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4333 	if (err != 0)

  4334 		{

  4335 		// At least one of the remaining three writes was completed.

  4336 		RPointerArray<CMMFBuffer>& bufferArray = *iBufferArray;

  4337 		CMMFDataBuffer* buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[3]);

  4338 		TInt writeLength = buffer->BufferSize();

  4339 		if (writeLength != iWriteLength)

  4340 			return EFail;

  4342 		TPtrC8 bufferData(buffer->Data().Ptr(), writeLength);

  4343 		iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4344 		err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4345 		if (err != 0)

  4346 			{

  4347 			iPosition += iWriteLength;

  4349 			buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[4]);

  4350 			writeLength = buffer->BufferSize();

  4351 			if (writeLength != iWriteLength)

  4352 				return EFail;

  4354 			bufferData.Set(buffer->Data().Ptr(), writeLength);

  4355 			iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4357 			err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4358 			if (err != 0)

  4359 				{

  4360 				iPosition += iWriteLength;

  4362 				buffer = STATIC_CAST(CMMFDataBuffer*, bufferArray[0]);

  4363 				writeLength = buffer->BufferSize();

  4364 				if (writeLength != iWriteLength)

  4365 					return EFail;

  4367 				bufferData.Set(buffer->Data().Ptr(), writeLength);

  4368 				iCopyOfDestinationDes.Replace(iPosition, iWriteLength, bufferData);

  4370 				err = Mem::Compare(destinationDes.Ptr(), length, iCopyOfDestinationDes.Ptr(), length);

  4371 				}

  4372 			}

  4373 		}

  4375 	CleanupStack::PopAndDestroy(destinationHBuf);

  4376 	CleanupStack::PopAndDestroy(&destinationFile);

  4377 	return err;

  4378 	}

  4381 TVerdict TAudioInputCreateSourceBuffer1TestStep::DoTestStepL()

  4382 	{

  4383 	CMMFAudioInput* source = STATIC_CAST(CMMFAudioInput*, iSource);

  4385 	TMediaId mediaId;

  4386 	CMMFBuffer* buffer = source->CreateSourceBufferL(mediaId);

  4388 	TVerdict result = EPass;

  4389 	if (buffer->Type() != KUidMmfDescriptorBuffer)

  4390 		result = EFail;

  4392 	if (buffer->Status() != EAvailable)

  4393 		result = EFail;

  4395 	CMMFDescriptorBuffer* descriptorBuffer = STATIC_CAST(CMMFDescriptorBuffer*, buffer);

  4396 	if (descriptorBuffer->Data().MaxLength() != (TInt)KAudioInputDefaultFrameSize)

  4397 		result = EFail;

  4399 	delete buffer;

  4400 	return result;

  4401 	}

  4403 TVerdict TAudioInputCreateSourceBuffer2TestStep::DoTestStepL()

  4404 	{

  4405 	CMMFAudioInput* source = STATIC_CAST(CMMFAudioInput*, iSource);

  4407 	TMediaId mediaId;

  4408 	CMMFBuffer* buffer = source->CreateSourceBufferL(mediaId, *iSinkBuffer);

  4410 	TVerdict result = EPass;

  4411 	if (buffer->Type() != KUidMmfDescriptorBuffer)

  4412 		result = EFail;

  4414 	if (buffer->Status() != EAvailable)

  4415 		result = EFail;

  4417 	CMMFDescriptorBuffer* descriptorBuffer = STATIC_CAST(CMMFDescriptorBuffer*, buffer);

  4418 	if (descriptorBuffer->Data().MaxLength() != (TInt)KAudioInputDefaultFrameSize)

  4419 		result = EFail;

  4421 	delete buffer;

  4422 	return result;

  4423 	}

  4425 TVerdict TAudioInputFillBufferTestStep::DoTestStepL()

  4426 	{

  4427 	TMediaId mediaId;

  4428 	TRAPD(err, iSource->FillBufferL(iBuffer, iSink, mediaId));	// first call inits

  4430 	if (err == KErrNone)

  4431 		CActiveScheduler::Start();

  4433 	TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4435 	if (err == KErrNone)

  4436 		CActiveScheduler::Start();

  4438 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4439 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4440 	if ((err != KErrNone) && sinkBufferFilledOk)

  4441 		return EFail;

  4443 	if (err != KErrNone)

  4444 		User::Leave(err);

  4446 	if (!sinkBufferFilledOk)

  4447 		{

  4448 		if ((err = dummySink->Error()) != KErrNone)

  4449 			User::Leave(err);

  4451 		return EFail;

  4452 		}

  4454 	return EPass;

  4455 	}

  4457 TVerdict TAudioInputFillBuffer2TestStep::DoTestStepL()

  4458 	{

  4459 	TMediaId mediaId;

  4460 	TRAPD(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4461 	if (err == KErrNone)

  4462 		CActiveScheduler::Start();

  4464 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4465 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4466 	if ((err != KErrNone) && sinkBufferFilledOk)

  4467 		return EFail;

  4469 	if (err != KErrNone)

  4470 		User::Leave(err);

  4472 	if (!sinkBufferFilledOk)

  4473 		{

  4474 		if ((err = dummySink->Error()) != KErrNone)

  4475 			User::Leave(err);

  4477 		return EFail;

  4478 		}

  4480 	TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4481 	if (err == KErrNone)

  4482 		CActiveScheduler::Start();

  4484 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  4485 	if ((err != KErrNone) && sinkBufferFilledOk)

  4486 		return EFail;

  4488 	if (err != KErrNone)

  4489 		User::Leave(err);

  4491 	if (!sinkBufferFilledOk)

  4492 		{

  4493 		if ((err = dummySink->Error()) != KErrNone)

  4494 			User::Leave(err);

  4496 		return EFail;

  4497 		}

  4499 	TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4500 	if (err == KErrNone)

  4501 		CActiveScheduler::Start();

  4503 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  4504 	if ((err != KErrNone) && sinkBufferFilledOk)

  4505 		return EFail;

  4507 	if (err != KErrNone)

  4508 		User::Leave(err);

  4510 	if (!sinkBufferFilledOk)

  4511 		{

  4512 		if ((err = dummySink->Error()) != KErrNone)

  4513 			User::Leave(err);

  4515 		return EFail;

  4516 		}

  4518 	return EPass;

  4519 	}

  4521 TVerdict TAudioInputFillBuffer3TestStep::DoTestStepL()

  4522 	{

  4523 	TMediaId mediaId;

  4524 	TInt requestCount = 0;

  4525 	TRAPD(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4526 	if (err == KErrNone)

  4527 		{

  4528 		requestCount++;

  4529 		TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4530 		if (err == KErrNone)

  4531 			{

  4532 			requestCount++;

  4533 			TRAP(err, iSource->FillBufferL(iBuffer, iSink, mediaId));

  4534 			}

  4535 		}

  4537 	if (err == KErrNone)

  4538 		requestCount++;

  4540 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4541 	if (requestCount)

  4542 		{

  4543 		dummySink->SetExpectedFillCount(requestCount);

  4544 		CActiveScheduler::Start();

  4545 		}

  4547 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4548 	if ((err != KErrNone) && sinkBufferFilledOk)

  4549 		return EFail;

  4551 	if (err != KErrNone)

  4552 		User::Leave(err);

  4554 	if (!sinkBufferFilledOk)

  4555 		{

  4556 		if ((err = dummySink->Error()) != KErrNone)

  4557 			User::Leave(err);

  4559 		return EFail;

  4560 		}

  4562 	return EPass;

  4563 	}

  4565 TVerdict TAudioInputFillBuffer4TestStep::DoTestStepL()

  4566 	{

  4567 	TBuf8<1> configDes;

  4568 	MDataSource* source = STATIC_CAST(MDataSource*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

  4569 	CleanupDeletePushL(source);

  4571 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4572 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  4573 	source->NegotiateSourceL(*dummySink);

  4574 	source->SourcePrimeL();

  4576 	TMediaId mediaId;

  4577 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4578 	if (err == KErrNone)

  4579 		CActiveScheduler::Start();

  4580 	CleanupStack::PopAndDestroy(source);

  4582 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4583 	if ((err != KErrNone) && sinkBufferFilledOk)

  4584 		return EFail;

  4586 	if (err != KErrNone)

  4587 		User::Leave(err);

  4589 	if (!sinkBufferFilledOk)

  4590 		{

  4591 		if ((err = dummySink->Error()) != KErrNone)

  4592 			User::Leave(err);

  4594 		return EFail;

  4595 		}

  4597 	return EPass;

  4598 	}

  4600 TVerdict TAudioInputFillBuffer5TestStep::DoTestStepL()

  4601 	{

  4602 	TBuf8<1> configDes;

  4603 	MDataSource* source = STATIC_CAST(MDataSource*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

  4604 	CleanupDeletePushL(source);

  4606 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4607 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  4608 	source->NegotiateSourceL(*dummySink);

  4609 	source->SourcePrimeL();

  4611 	TMediaId mediaId;

  4612 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4613 	if (err == KErrNone)

  4614 		CActiveScheduler::Start();

  4616 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4617 	if ((err != KErrNone) && sinkBufferFilledOk)

  4618 		{

  4619 		CleanupStack::PopAndDestroy(source);

  4620 		return EFail;

  4621 		}

  4623 	if (err != KErrNone)

  4624 		User::Leave(err);

  4626 	if (!sinkBufferFilledOk)

  4627 		{

  4628 		if ((err = dummySink->Error()) != KErrNone)

  4629 			User::Leave(err);

  4631 		CleanupStack::PopAndDestroy(source);

  4632 		return EFail;

  4633 		}

  4635 	TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4636 	if (err == KErrNone)

  4637 		CActiveScheduler::Start();

  4639 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  4640 	if ((err != KErrNone) && sinkBufferFilledOk)

  4641 		{

  4642 		CleanupStack::PopAndDestroy(source);

  4643 		return EFail;

  4644 		}

  4646 	if (err != KErrNone)

  4647 		User::Leave(err);

  4649 	if (!sinkBufferFilledOk)

  4650 		{

  4651 		if ((err = dummySink->Error()) != KErrNone)

  4652 			User::Leave(err);

  4654 		CleanupStack::PopAndDestroy(source);

  4655 		return EFail;

  4656 		}

  4658 	TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4659 	if (err == KErrNone)

  4660 		CActiveScheduler::Start();

  4662 	sinkBufferFilledOk = dummySink->BufferFilledOk();

  4663 	if ((err != KErrNone) && sinkBufferFilledOk)

  4664 		{

  4665 		CleanupStack::PopAndDestroy(source);

  4666 		return EFail;

  4667 		}

  4669 	if (err != KErrNone)

  4670 		User::Leave(err);

  4672 	if (!sinkBufferFilledOk)

  4673 		{

  4674 		if ((err = dummySink->Error()) != KErrNone)

  4675 			User::Leave(err);

  4677 		CleanupStack::PopAndDestroy(source);

  4678 		return EFail;

  4679 		}

  4681 	CleanupStack::PopAndDestroy(source);

  4682 	return EPass;

  4683 	}

  4685 TVerdict TAudioInputFillBuffer6TestStep::DoTestStepL()

  4686 	{

  4687 	TBuf8<1> configDes;

  4688 	MDataSource* source = STATIC_CAST(MDataSource*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

  4689 	CleanupDeletePushL(source);

  4691 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4692 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  4693 	source->NegotiateSourceL(*dummySink);

  4694 	source->SourcePrimeL();

  4696 	TMediaId mediaId;

  4697 	TInt requestCount = 0;

  4698 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4699 	if (err == KErrNone)

  4700 		{

  4701 		requestCount++;

  4702 		TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4703 		if (err == KErrNone)

  4704 			{

  4705 			requestCount++;

  4706 			TRAP(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4707 			}

  4708 		}

  4710 	if (err == KErrNone)

  4711 		requestCount++;

  4713 	if (requestCount)

  4714 		{

  4715 		dummySink->SetExpectedFillCount(requestCount);

  4716 		CActiveScheduler::Start();

  4717 		}

  4718 	CleanupStack::PopAndDestroy(source);

  4720 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4721 	if ((err != KErrNone) && sinkBufferFilledOk)

  4722 		return EFail;

  4724 	if (err != KErrNone)

  4725 		User::Leave(err);

  4727 	if (!sinkBufferFilledOk)

  4728 		{

  4729 		if ((err = dummySink->Error()) != KErrNone)

  4730 			User::Leave(err);

  4732 		return EFail;

  4733 		}

  4735 	return EPass;

  4736 	}

  4738 TVerdict TAudioInputFillBuffer7TestStep::DoTestStepL()

  4739 	{

  4740 	TBuf8<1> configDes;

  4741 	MDataSource* source = STATIC_CAST(MDataSource*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

  4742 	CleanupDeletePushL(source);

  4744 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4745 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  4746 	source->NegotiateSourceL(*dummySink);

  4747 	source->SourcePrimeL();

  4749 	TMediaId mediaId;

  4750 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4751 	if (err == KErrNone)

  4752 		CActiveScheduler::Start();

  4754 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4755 	if ((err != KErrNone) && sinkBufferFilledOk)

  4756 		{

  4757 		CleanupStack::PopAndDestroy(source);

  4758 		return EFail;

  4759 		}

  4761 	if (err != KErrNone)

  4762 		User::Leave(err);

  4764 	if (!sinkBufferFilledOk)

  4765 		{

  4766 		if ((err = dummySink->Error()) != KErrNone)

  4767 			User::Leave(err);

  4769 		CleanupStack::PopAndDestroy(source);

  4770 		return EFail;

  4771 		}

  4773 	source->SourcePauseL();

  4774 	source->FillBufferL(iBuffer, iSink, mediaId);	// this call just inits devsound

  4775 //DevSound WP source is active cannot dictate what buffers to fill

  4776 //	source->FillBufferL(iBuffer, iSink, mediaId);	// this call should leave with KErrNotReady

  4778 	CleanupStack::PopAndDestroy(source);

  4779 	return EPass;

  4780 	}

  4782 TVerdict TAudioInputFillBuffer8TestStep::DoTestStepL()

  4783 	{

  4784 	TBuf8<1> configDes;

  4785 	MDataSource* source = STATIC_CAST(MDataSource*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

  4786 	CleanupDeletePushL(source);

  4788 	CMMFDummySink* dummySink = STATIC_CAST(CMMFDummySink*, iSink);

  4789 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  4790 	source->NegotiateSourceL(*dummySink);

  4791 	source->SourcePrimeL();

  4793 	TMediaId mediaId;

  4794 	TRAPD(err, source->FillBufferL(iBuffer, iSink, mediaId));

  4795 	if (err == KErrNone)

  4796 		CActiveScheduler::Start();

  4798 	TBool sinkBufferFilledOk = dummySink->BufferFilledOk();

  4799 	if ((err != KErrNone) && sinkBufferFilledOk)

  4800 		{

  4801 		CleanupStack::PopAndDestroy(source);

  4802 		return EFail;

  4803 		}

  4805 	if (err != KErrNone)

  4806 		User::Leave(err);

  4808 	if (!sinkBufferFilledOk)

  4809 		{

  4810 		if ((err = dummySink->Error()) != KErrNone)

  4811 			User::Leave(err);

  4813 		CleanupStack::PopAndDestroy(source);

  4814 		return EFail;

  4815 		}

  4817 	source->SourceStopL();

  4818 	source->FillBufferL(iBuffer, iSink, mediaId);	// this call just inits devsound

  4819 	source->FillBufferL(iBuffer, iSink, mediaId);	// this call should leave with KErrNotReady

  4821 	CleanupStack::PopAndDestroy(source);

  4822 	return EPass;

  4823 	}

  4826 TVerdict TAudioOutputEmptyBufferTestStep::DoTestStepL()

  4827 	{

  4828 	TMediaId mediaId;

  4829 	iSink->SinkPlayL();

  4831 	TRAPD(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  4833 	if ((err == KErrNone) && iAsynchronousWrite)

  4834 		CActiveScheduler::Start();

  4836 	iSink->SinkStopL();

  4838 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4839 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4840 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  4841 		return EFail;

  4843 	if (err != KErrNone)

  4844 		User::Leave(err);

  4846 	if (!sourceBufferEmptiedOk)

  4847 		{

  4848 		if ((err = dummySource->Error()) != KErrNone)

  4849 			User::Leave(err);

  4851 		return EFail;

  4852 		}

  4854 	return EPass;

  4855 	}

  4857 TVerdict TAudioOutputEmptyBuffer2TestStep::DoTestStepL()

  4858 	{

  4859 	TMediaId mediaId;

  4860 	iSink->SinkPlayL();

  4862 	TRAPD(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  4863 	if ((err == KErrNone) && iAsynchronousWrite)

  4864 		CActiveScheduler::Start();

  4866 	iSink->SinkStopL();

  4868 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4869 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4870 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  4871 		return EFail;

  4873 	if (err != KErrNone)

  4874 		{

  4875 		iSink->SinkStopL();

  4876 		User::Leave(err);

  4877 		}

  4879 	if (!sourceBufferEmptiedOk)

  4880 		{

  4881 		if ((err = dummySource->Error()) != KErrNone)

  4882 			{

  4883 			iSink->SinkStopL();

  4884 			User::Leave(err);

  4885 			}

  4887 		return EFail;

  4888 		}

  4890 	iSink->SinkPlayL();

  4892 	TRAP(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  4893 	if ((err == KErrNone) && iAsynchronousWrite)

  4894 		CActiveScheduler::Start();

  4896 	iSink->SinkStopL();

  4898 	sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4899 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  4900 		return EFail;

  4902 	if (err != KErrNone)

  4903 		{

  4904 		iSink->SinkStopL();

  4905 		User::Leave(err);

  4906 		}

  4908 	if (!sourceBufferEmptiedOk)

  4909 		{

  4910 		if ((err = dummySource->Error()) != KErrNone)

  4911 			{

  4912 			iSink->SinkStopL();

  4913 			User::Leave(err);

  4914 			}

  4916 		return EFail;

  4917 		}

  4919 	iSink->SinkPlayL();

  4921 	TRAP(err, iSink->EmptyBufferL(iBuffer, iSource, mediaId));

  4922 	if ((err == KErrNone) && iAsynchronousWrite)

  4923 		CActiveScheduler::Start();

  4925 	iSink->SinkStopL();

  4927 	sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4928 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  4929 		return EFail;

  4931 	if (err != KErrNone)

  4932 		User::Leave(err);

  4934 	if (!sourceBufferEmptiedOk)

  4935 		{

  4936 		if ((err = dummySource->Error()) != KErrNone)

  4937 			User::Leave(err);

  4939 		return EFail;

  4940 		}

  4942 	return EPass;

  4943 	}

  4945 TVerdict TAudioOutputEmptyBuffer3TestStep::DoTestStepL()

  4946 	{

  4947 	// Fill in!

  4948 	return EPass;

  4949 	}

  4951 TVerdict TAudioOutputEmptyBuffer4TestStep::DoTestStepL()

  4952 	{

  4953 	TBuf8<1> configDes;

  4954 	MDataSink* sink = STATIC_CAST(MDataSink*, MDataSink::NewSinkL(KUidMmfAudioOutput, configDes));

  4955 	CleanupDeletePushL(sink);

  4957 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4959 	//DevSound WP Logon must come before Prime

  4960 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  4961 	sink->SinkPrimeL();

  4962 	//DevSound WP User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  4964 	sink->NegotiateL(iRealFormat);

  4966 	TMediaId mediaId;

  4967 	sink->SinkPlayL();

  4968 	TRAPD(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  4969 	CActiveScheduler::Start();

  4970 	CleanupStack::PopAndDestroy(sink);

  4972 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  4973 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  4974 		return EFail;

  4976 	if (err != KErrNone)

  4977 		User::Leave(err);

  4979 	if (!sourceBufferEmptiedOk)

  4980 		{//DevSound WP because the active scheduler can leave

  4981 		//we cannot assume that the source buffer has been emptied ok in the alloc test

  4982 		//	if ((err = dummySource->Error()) != KErrNone)

  4983 		//		User::Leave(err);

  4985 		//	return EFail;

  4986 		}

  4988 	return EPass;

  4989 	}

  4991 TVerdict TAudioOutputEmptyBuffer5TestStep::DoTestStepL()

  4992 	{

  4993 	TBuf8<1> configDes;

  4994 	MDataSink* sink = STATIC_CAST(MDataSink*, MDataSink::NewSinkL(KUidMmfAudioOutput, configDes));

  4995 	CleanupDeletePushL(sink);

  4997 	CMMFDummySource* dummySource = STATIC_CAST(CMMFDummySource*, iSource);

  4999 	//DevSound WP Logon must come before Prime

  5000 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  5001 	sink->SinkPrimeL();

  5002 	//DevSound WP	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  5004 	sink->NegotiateL(iRealFormat);

  5005 	sink->SinkPlayL();

  5007 	TMediaId mediaId;

  5008 	TRAPD(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  5010 	CActiveScheduler::Start();

  5012 	TBool sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  5013 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  5014 		{

  5015 		CleanupStack::PopAndDestroy(sink);

  5016 		return EFail;

  5017 		}

  5019 	if (err != KErrNone)

  5020 		User::Leave(err);

  5022 	if (!sourceBufferEmptiedOk)

  5023 		{

  5024 		/* DevSound WP may not be emptied ok if OOM in AS

  5025 		if ((err = dummySource->Error()) != KErrNone)

  5026 			User::Leave(err);

  5028 		CleanupStack::PopAndDestroy(sink);

  5029 		return EFail;

  5030 		*/

  5031 		}

  5033 	dummySource->SetActiveScheduler();

  5034 	TRAP(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  5035 	if (err == KErrNone)

  5036 		CActiveScheduler::Start();

  5038 	sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  5039 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  5040 		{

  5041 		CleanupStack::PopAndDestroy(sink);

  5042 		return EFail;

  5043 		}

  5045 	if (err != KErrNone)

  5046 		User::Leave(err);

  5048 	if (!sourceBufferEmptiedOk)

  5049 		{

  5050 		if ((err = dummySource->Error()) != KErrNone)

  5051 			User::Leave(err);

  5053 		CleanupStack::PopAndDestroy(sink);

  5054 		return EFail;

  5055 		}

  5057 	TRAP(err, sink->EmptyBufferL(iBuffer, iSource, mediaId));

  5058 	if (err == KErrNone)

  5059 		CActiveScheduler::Start();

  5061 	sourceBufferEmptiedOk = dummySource->BufferEmptiedOk();

  5062 	if ((err != KErrNone) && sourceBufferEmptiedOk)

  5063 		{

  5064 		CleanupStack::PopAndDestroy(sink);

  5065 		return EFail;

  5066 		}

  5068 	if (err != KErrNone)

  5069 		User::Leave(err);

  5071 	if (!sourceBufferEmptiedOk)

  5072 		{

  5073 		if ((err = dummySource->Error()) != KErrNone)

  5074 			User::Leave(err);

  5076 		CleanupStack::PopAndDestroy(sink);

  5077 		return EFail;

  5078 		}

  5080 	CleanupStack::PopAndDestroy(sink);

  5081 	return EPass;

  5082 	}

  5085 //_LIT(KTest301CopyFileName, "c:\\mm\\mmf\\testfiles\\srssnk\\CopyOfMMFTestFile1.dat");	// EABI warning removal

  5086 _LIT(KTest301FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile1.wav");

  5088 TVerdict TPrimeStopTestStep::DoTestStepL()

  5089 	{

  5090 	// Initialise config data.

  5091 	TMMFFileConfig configDes;

  5092 	configDes().iPath = KTest301FileName;

  5093 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

  5094 	CleanupDeletePushL(source);

  5096 	TUid KWavReadUid = { KMmfUidFormatWAVRead };

  5097 	CMMFFormatDecode* format = CMMFFormatDecode::NewL(KWavReadUid, source);

  5098 	CleanupStack::PushL(format);

  5100 	// Initialise thread active scheduler.

  5101 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  5102 	CleanupStack::PushL(scheduler);

  5103 	CActiveScheduler::Install(scheduler);

  5105 	// Prime

  5106 	TRAPD(err, format->SourcePrimeL());

  5108 	if (err != KErrNone)

  5109 		{

  5110 		format->SourcePrimeL();

  5111 		}

  5113 	// This will leave during alloc fail test

  5114 	TAny* randomAlloc = User::AllocL(10);

  5115 	User::Free(randomAlloc);

  5117 	CleanupStack::PopAndDestroy(scheduler);

  5118 	CleanupStack::PopAndDestroy(format);

  5119 	CleanupStack::PopAndDestroy(source);

  5121 	return EPass;

  5122 	}

  5125 _LIT(KTest302FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile1.wav");

  5127 TVerdict TPrimeStopSinkTestStep::DoTestStepL()

  5128 	{

  5129 	// Create a new sink.

  5130 	TBuf8<1> dummyConfigDes;

  5131 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, dummyConfigDes);

  5132 	CleanupDeletePushL(sink);

  5134 	// Create a real source.

  5135 	// Initialise config data.

  5136 	TMMFFileConfig configDes;

  5137 	configDes().iPath = KTest302FileName;

  5138 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

  5139 	CleanupDeletePushL(source);

  5141 	TUid KWavReadUid = { KMmfUidFormatWAVRead };

  5142 	CMMFFormatDecode* format = CMMFFormatDecode::NewL(KWavReadUid, source);

  5143 	CleanupStack::PushL(format);

  5145 	CMMFWavFormatRead* realFormat = static_cast<CMMFWavFormatRead*>(format);

  5146 	User::LeaveIfError(sink->SinkThreadLogon(*realFormat));

  5147 	sink->NegotiateL(*format);

  5149 	TRAPD(err, sink->SinkPrimeL());

  5150 	if (err != KErrNone)

  5151 		{

  5152 		sink->SinkPrimeL();

  5153 		}

  5155 	CleanupStack::PopAndDestroy(format);

  5156 	CleanupStack::PopAndDestroy(source);

  5157 	CleanupStack::PopAndDestroy(sink);

  5159 	return EPass;

  5160 	}

  5162 /**

  5163  *

  5164  * CTestStepSelfTest constructor

  5165  *

  5166  * @xxxx

  5167  *

  5168  */

  5169 CTestStep_MMF_SRSSNK::CTestStep_MMF_SRSSNK(TBool aIsAllocTest)

  5170 : iTestResult(EPass), iIsAllocTest(aIsAllocTest)

  5171 	{

  5172 	iHeapSize = 1048576; // 1M

  5174 	RFs theFs;

  5175 	if (theFs.Connect() == KErrNone)

  5176 		{

  5177 		if (theFs.SetErrorCondition(KErrNone) == KErrNone)

  5178 			iFileFailureTestingEnabled = ETrue;

  5180 		theFs.Close();

  5181 		}

  5182 	}

  5184 /**

  5185  *

  5186  * CTestStepSelfTest destructor

  5187  *

  5188  * @xxxx

  5189  *

  5190  */

  5191 CTestStep_MMF_SRSSNK::~CTestStep_MMF_SRSSNK()

  5192 	{

  5193 	}

  5195 void CTestStep_MMF_SRSSNK::DoTest(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount)

  5196 	{

  5197 	DoTestStep(aTestStep, aTestDescription, aExpectedTestResult, aHeapCellCount);

  5198 	DoTestStepWithAllocFail(aTestStep, aTestDescription, aExpectedTestResult, aHeapCellCount);

  5199 	}

  5201 void CTestStep_MMF_SRSSNK::DoFileTest(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult)

  5202 	{

  5203 	DoTestStep(aTestStep, aTestDescription, aExpectedTestResult);

  5204 	DoTestStepWithAllocFail(aTestStep, aTestDescription, aExpectedTestResult);

  5206 	DoTestStepWithFileFail(aTestStep, aTestDescription, aExpectedTestResult);

  5208 	// The test below is no longer run. Running it will cause an ASSERT.

  5209 	//DoTestStepWithAllocAndFileFail(aTestStep, aTestDescription, aExpectedTestResult);

  5210 	}

  5212 void CTestStep_MMF_SRSSNK::DoFileTestWithoutAllocFail(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt aHeapCellCount)

  5213 	{

  5214 	DoTestStep(aTestStep, aTestDescription, aExpectedTestResult, aHeapCellCount);

  5215 	DoTestStepWithFileFail(aTestStep, aTestDescription, aExpectedTestResult, aHeapCellCount);

  5216 	}

  5218 void CTestStep_MMF_SRSSNK::DoTestStep(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedTestResult, TInt /*__REQUIREDFORDEBUG(aHeapCellCount)*/)

  5219 	{

  5220 	TVerdict verdict = EPass;

  5222 	TRAPD(preErr, aTestStep.DoTestPreambleL());

  5224 	if (preErr != KErrNone)

  5225 		{

  5226 		INFO_PRINTF3(_L("%S: Test pre amble failed %d\n"), &aTestDescription, preErr);

  5227 		iTestResult = EFail;

  5228 		return;

  5229 		}

  5231 	TRAPD(leaveErr, verdict = aTestStep.DoTestStepL());

  5233 	if (verdict == EPass)

  5234 		{

  5235 		if (leaveErr != aExpectedTestResult)

  5236 			{

  5237 			INFO_PRINTF3(_L("DoTestStep failed: leaveErr (%d) != expected (%d)"), leaveErr, aExpectedTestResult);

  5238 			verdict = EFail;

  5239 			}

  5240 		else if (leaveErr == KErrNone)

  5241 			{

  5242 			TRAPD(postErr, verdict = aTestStep.DoTestPostambleL(ETrue));

  5243 			if (postErr != KErrNone)

  5244 				{

  5245 				INFO_PRINTF2(_L("DoTestStep failed: postErr (%d)"), postErr);

  5246 				verdict = EInconclusive;

  5247 				}

  5248 			}

  5249 		else

  5250 			{

  5251 			TRAPD(postErr, verdict = aTestStep.DoNegativeTestPostambleL());

  5252 			if (postErr != KErrNone)

  5253 				{

  5254 				INFO_PRINTF2(_L("DoTestStep failed: postErr (%d)"), postErr);

  5255 				verdict = EInconclusive;

  5256 				}

  5257 			}

  5258 		}

  5260 	if (verdict != EPass)

  5261 		{

  5262 		INFO_PRINTF3(_L("%S: Test verdict = %d\n"), &aTestDescription, verdict);

  5263 		INFO_PRINTF4(_L("%S: Expecting %d, actually got %d\n"), &aTestDescription, aExpectedTestResult, leaveErr);

  5264 		iTestResult = verdict;

  5265 		}

  5266 	}

  5268 void CTestStep_MMF_SRSSNK::DoTestStepWithAllocFail(TTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedResult, TInt /*__REQUIREDFORDEBUG(aHeapCellCount)*/)

  5269 	{

  5270 	TInt err;

  5271 	TInt postErr;

  5272 	TInt failPoint = 0;

  5273 	TBool finished = EFalse;

  5274 	TVerdict verdict;

  5275 	TVerdict postVerdict;

  5277 	iTestResult = EFail;

  5278 	do

  5279 		{

  5280 		// Do the preamble.

  5281 		TRAP(err, aTestStep.DoTestPreambleL());

  5282 		if (err != KErrNone)

  5283 			{

  5284 			INFO_PRINTF2(_L("%S preamble failed"), &aTestDescription);

  5285 			TRAP_IGNORE(aTestStep.DoNegativeTestPostambleL());

  5286 			return;

  5287 			}

  5289 		// Do the test step.

  5290 		failPoint = failPoint + 1;	// doing 'failPoint++' causes a compiler warning on ARMV5 UREL.

  5291 		__UHEAP_SETFAIL(RHeap::EFailNext, failPoint);

  5292 		verdict = EFail;

  5293 		TRAP(err, verdict = aTestStep.DoTestStepL());

  5295 		TAny* ptr = User::Alloc(1);

  5296 		finished = (ptr == NULL);

  5297 		User::Free(ptr);

  5298 		__UHEAP_RESET;

  5300 		// Do the postamble.

  5301 		postVerdict = EFail;

  5302 		if (err == KErrNone)

  5303 			{

  5304 			TRAP(postErr, postVerdict = aTestStep.DoTestPostambleL(ETrue));

  5305 			}

  5306 		else

  5307 			{

  5308 			TRAP(postErr, postVerdict = aTestStep.DoNegativeTestPostambleL());

  5309 			}

  5311 		// Check postamble results.

  5312 		if ((postErr != KErrNone) && (postVerdict != EPass))

  5313 			{

  5314 			INFO_PRINTF3(_L("Postamble failed: %d (postVerdict = %d)"), postErr, postVerdict);

  5315 			return;

  5316 			}

  5317 		}

  5318 	while (!finished);

  5320 	// Check we got the expected result.

  5321 	if ((aExpectedResult == KErrNone) && (verdict != EPass))

  5322 		{

  5323 		INFO_PRINTF2(_L("TestStep failed: %d"), verdict);

  5324 		return;

  5325 		}

  5327 	iTestResult = (err == aExpectedResult ? EPass : EFail);

  5328 	}

  5330 void CTestStep_MMF_SRSSNK::DoTestStepWithFileFail(TFileTestStep& aTestStep, TPtrC /*aTestDescription*/, TInt aExpectedResult, TInt /*__REQUIREDFORDEBUG(aHeapCellCount)*/)

  5331 	{

  5332 	RFs fs;

  5333 	TInt err;

  5334 	TInt postErr;

  5335 	TBool isExpectedResult;

  5336 	TVerdict verdict;

  5337 	TVerdict postVerdict = EPass;

  5339 	iTestResult = EPass;

  5340 	if (!iFileFailureTestingEnabled)

  5341 		{

  5342 		return;

  5343 		}

  5345 	err = fs.Connect();

  5346 	if (err != KErrNone)

  5347 		{

  5348 		User::Panic(_L("SRSSNK Test"), err);

  5349 		}

  5351 	aTestStep.iFileFailureExpected = ETrue;

  5353 	// Once Base's DEF103757 has been submitted to the MCL

  5354 	// the counter 'failAt' should be set to zero.

  5355 	// DP roms need to have this number set higher due to the

  5356 	// additional paging operations done by RFs.

  5357 	TInt failAt = 15;

  5358 	do

  5359 		{

  5360 		// Do the preamble.

  5361 		TRAP(err, aTestStep.DoTestPreambleL());

  5362 		if (err != KErrNone)

  5363 			{

  5364 			iTestStepResult = EInconclusive;

  5365 			fs.Close();

  5366 			return;

  5367 			}

  5369 		// Set the file failure point.

  5370 		fs.SetErrorCondition(KErrFileFail, failAt++);

  5371 		verdict = EFail;

  5372 		TRAP(err, verdict = aTestStep.DoTestStepL());

  5373 		fs.SetErrorCondition(KErrNone);

  5375 		isExpectedResult = (err == aExpectedResult);

  5377 		postVerdict = EFail;

  5378 		if (err == KErrNone)

  5379 			{

  5380 			TRAP(postErr, postVerdict = aTestStep.DoTestPostambleL(ETrue));

  5381 			}

  5382 		else

  5383 			{

  5384 			TRAP(postErr, postVerdict = aTestStep.DoNegativeTestPostambleL());

  5385 			}

  5386 		}

  5387 	while (err == KErrFileFail);

  5389 	fs.Close();

  5391 	// Decide the test result.

  5392 	if ((postErr != KErrNone) || (postVerdict != EPass))

  5393 		{

  5394 		iTestResult = postVerdict;

  5395 		return;

  5396 		}

  5398 	// If there's an expected failure, verdict will be EFail.

  5399 	// This doesn't mean the test has failed.

  5400 	if ((aExpectedResult == KErrNone) && (verdict != EPass))

  5401 		{

  5402 		iTestResult = verdict;

  5403 		return;

  5404 		}

  5406 	iTestResult = (isExpectedResult ? EPass : EFail);

  5407 	}

  5409 //

  5410 // The test is no longer run as its correctness is not proven.

  5411 // It is kept for reference purposes.

  5412 //

  5413 void CTestStep_MMF_SRSSNK::DoTestStepWithAllocAndFileFail(TFileTestStep& aTestStep, TPtrC aTestDescription, TInt aExpectedResult)

  5414 	{

  5415 	ASSERT(0);	// Don't run this test.

  5417 	if (!iFileFailureTestingEnabled)

  5418 		return;

  5420 	RFs theFs;

  5421 	TInt leaveErr = theFs.Connect();

  5422 	if (leaveErr != KErrNone)

  5423 		User::Panic(_L("SRSSNK Test"), 0);

  5425 	aTestStep.iFileFailureExpected = ETrue;

  5426 	TVerdict verdict = EPass;

  5427 	TBool allocTestingComplete;

  5428 	for (TInt failAt = 1, fileFailAt = KStartFileFailAt ; ; failAt++)

  5429 		{

  5430 		for (; ; fileFailAt++)

  5431 			{

  5432 			TRAPD(preErr, aTestStep.DoTestPreambleL());

  5433 			if (preErr != KErrNone)

  5434 			{

  5435 				INFO_PRINTF2(_L("%S: Test pre amble failed\n"), &aTestDescription);

  5436 				iTestResult = EFail;

  5437 				return;

  5438 			}

  5440 			__UHEAP_SETFAIL(RHeap::EFailNext, failAt);	// Leavescan will complain about this, although it isn't a leaving function

  5441 			theFs.SetErrorCondition(KErrFileFail, fileFailAt);

  5442  			TRAP(leaveErr, verdict = aTestStep.DoTestStepL());

  5443 			theFs.SetErrorCondition(KErrNone);

  5445 			TAny* testAlloc = User::Alloc(1);

  5446 			allocTestingComplete = (testAlloc == NULL);

  5447 			User::Free(testAlloc);

  5448 			__UHEAP_SETFAIL(RHeap::ENone, 0);

  5450 			if (verdict == EPass)

  5451 				{

  5452 				if ((leaveErr != aExpectedResult) && (leaveErr != KErrFileFail) && (leaveErr != KErrNoMemory))

  5453 					verdict = EFail;

  5454 				else if (leaveErr == KErrNone)

  5455 					{

  5456 					TRAPD(postErr, verdict = aTestStep.DoTestPostambleL(ETrue));

  5457 					if (postErr != KErrNone)

  5458 						verdict = EInconclusive;

  5459 					}

  5460 				else

  5461 					{

  5462 					// ignore the verdict from DoNegativeTestPostambleL()

  5463 					// since the main test has failed it's likely to fail too

  5464 					TRAPD(postErr, aTestStep.DoNegativeTestPostambleL());

  5465 					if (postErr != KErrNone)

  5466 						verdict = EInconclusive;

  5467 					}

  5468 				}

  5470 			if (verdict != EPass)

  5471 				{

  5472 				INFO_PRINTF3(_L("%S + alloc+file fail: Test verdict = %d\n"), &aTestDescription, verdict);

  5473 				INFO_PRINTF4(_L("%S + alloc+file fail: Expecting %d, actually got %d"), &aTestDescription, aExpectedResult, leaveErr);

  5475 				iTestResult = verdict;

  5476 				break;

  5477 				}

  5479 			if ((leaveErr == aExpectedResult) || (leaveErr == KErrNoMemory))

  5480 				break;

  5481 			}

  5483 		if (verdict == EPass)

  5484 			{

  5485 			if (allocTestingComplete)

  5486 				{

  5487 				if (leaveErr != aExpectedResult)

  5488 					{

  5489 					INFO_PRINTF3(_L("%S + alloc fail: Test verdict = %d\n"), &aTestDescription, EFail);

  5490 					INFO_PRINTF4(_L("%S + alloc fail: Expecting %d, actually got %d"), &aTestDescription, aExpectedResult, leaveErr);

  5492 					iTestResult = EFail;

  5493 					}

  5495 				break;

  5496 				}

  5497 			}

  5498 		else

  5499 			{

  5500 				// added 17/01/03 - prevents looping on EFail

  5501 				iTestResult = verdict;

  5502 				break;

  5503 			}

  5504 		}

  5505 	aTestStep.iFileFailureExpected = EFalse;

  5506 	theFs.Close();

  5507 	}

  5509 TVerdict CTestStep_MMF_SRSSNK::OpenL()

  5510 	{

  5511 	if (iIsAllocTest)

  5512 		{

  5513 		// see if alloc fail stuff is enabled - ask if next alloc test will fail

  5514 		__UHEAP_SETFAIL(RHeap::EFailNext, 1);

  5515 		TAny *testAlloc = User::Alloc(1);

  5516 		TBool workingOk = testAlloc == NULL;

  5517 		User::Free(testAlloc);

  5518 		__UHEAP_SETFAIL(RHeap::ENone ,0);

  5520 		if (!workingOk)

  5521 			{

  5522 			ERR_PRINTF1(_L("Alloc Testing does not work on this build"));

  5523 			return EInconclusive;

  5524 			}

  5525 		}

  5527 	return EPass;

  5528 	}

  5530 void CTestStep_MMF_SRSSNK::CopyFileL(RFs& aFs, const TDesC& aOld, const TDesC& aNew)

  5531 	{

  5532 	CFileMan* fileMan = CFileMan::NewL(aFs);

  5533 	CleanupStack::PushL(fileMan);

  5534 	User::LeaveIfError(fileMan->Copy(aOld, aNew));

  5535 	CleanupStack::PopAndDestroy(fileMan);

  5536 	}

  5538 void CTestStep_MMF_SRSSNK::OpenFileL(const TDesC& aFileName, TInt aMode, TBool aShareProtected)

  5539 	{

  5540 	User::LeaveIfError(iFs.Connect());

  5542 	if (aShareProtected)

  5543 		{

  5544 		User::LeaveIfError(iFs.ShareProtected());

  5545 		}

  5547 	User::LeaveIfError(iFile.Open(iFs, aFileName, aMode));

  5548 	}

  5552 void CTestStep_MMF_SRSSNK::CloseFile()

  5553 	{

  5554 	iFile.Close();

  5555 	iFs.Close();

  5556 	}

  5558 void CTestStep_MMF_SRSSNK::DeleteFileSinkL(TSinkType aSinkType, RFs& aFs, TDesC& aFileName)

  5559 	{

  5560 	// Delete the test file.

  5561 	CMMFClip* sink = static_cast<CMMFClip*> (CreateFileSinkL(aSinkType, aFs, aFileName));

  5563 	CleanupStack::PushL(sink);

  5564 	TInt err = sink->Delete();

  5565 	CleanupStack::PopAndDestroy(sink);

  5567 		// can't use Delete from File Sink itself - when using file handles, must delete it once file is closed

  5568 	if (aSinkType == ESinkTypeFileHandle)

  5569 		{

  5570 		err = aFs.Delete(aFileName);

  5571 		}

  5573 	if (err != KErrNone && err != KErrNotFound)

  5574 		{

  5575 		INFO_PRINTF2(_L("Error deleting file sink %d"), err);

  5576 		User::Leave(err);

  5577 		}

  5578 	}

  5580 // Test support classes

  5581 CMMFDummySource::CMMFDummySource()

  5582 : MDataSource(KTestDummyUid), iExpectedEmptyCount(1), iActiveScheduler(CActiveScheduler::Current()), iFillBuffer(EFalse)

  5583 	{

  5584 	}

  5586 TFourCC CMMFDummySource::SourceDataTypeCode(TMediaId /*aMediaId*/)

  5587 	{

  5588 	User::Panic(_L("SRSSNK Test"), 0);

  5589 	return iSourceDataTypeCode;

  5590 	}

  5592 void CMMFDummySource::FillBufferL(CMMFBuffer* /*aBuffer*/ , MDataSink* /*aConsumer*/, TMediaId /*aMediaId*/)

  5593 	{

  5594 	User::Panic(_L("SRSSNK Test"), 0);

  5595 	}

  5597 void CMMFDummySource::BufferEmptiedL(CMMFBuffer* aBuffer)

  5598 	{

  5599 	iEmptyCount++;

  5600 	if (iEmptyCount == iExpectedEmptyCount)

  5601 		iBufferEmptiedOk = ETrue;

  5603 	if ((iActiveScheduler != NULL) && iBufferEmptiedOk)

  5604 		CActiveScheduler::Stop();

  5606 	if (iFillBuffer)

  5607 		{

  5608 		CMMFDataBuffer* dataBuffer = STATIC_CAST(CMMFDataBuffer*, aBuffer);

  5609 		dataBuffer->Data().SetLength(KTestWriteSize);

  5610 		}

  5612 	iBuffer = aBuffer;	// save for test 208

  5613 	}

  5615 TInt CMMFDummySource::SendEventToClient(const TMMFEvent& aEvent)

  5616 	{

  5617 	if (aEvent.iErrorCode == KErrCancel) // Ignore stop.

  5618 		{

  5619 		return 0;

  5620 		}

  5622 	//DevSound WP active scheduler should also be stopped for OOM error

  5623 	//since OOM can occur during active scheduler

  5624 	if ((iActiveScheduler != NULL) && (aEvent.iErrorCode == KErrNoMemory))

  5625 		{

  5626 		iError = aEvent.iErrorCode;

  5627 		CActiveScheduler::Stop();

  5628 		return 0;

  5629 		}

  5631 	iError = aEvent.iErrorCode;

  5632 	iErrorCount++;

  5634 	iEmptyCount++;

  5635 	if ((iActiveScheduler != NULL) && (iEmptyCount == iExpectedEmptyCount))

  5636 		CActiveScheduler::Stop();

  5638 	return 0;

  5639 	}

  5641 TBool CMMFDummySource::CanCreateSourceBuffer()

  5642 	{

  5643 	User::Panic(_L("SRSSNK Test"), 0);

  5644 	return EFalse;

  5645 	}

  5647 CMMFBuffer* CMMFDummySource::CreateSourceBufferL(TMediaId /*aMediaId*/, TBool& /*aReference*/)

  5648 	{

  5649 	User::Panic(_L("SRSSNK Test"), 0);

  5650 	return NULL;

  5651 	}

  5653 void CMMFDummySource::ConstructSourceL(const TDesC8& /*aInitData*/)

  5654 	{

  5655 	User::Panic(_L("SRSSNK Test"), 0);

  5656 	}

  5659 CMMFDummySink::CMMFDummySink()

  5660 : MDataSink(KTestDummyUid), iExpectedFillCount(1), iActiveScheduler(CActiveScheduler::Current())

  5661 	{

  5662 	}

  5664 TFourCC CMMFDummySink::SinkDataTypeCode(TMediaId /*aMediaId*/)

  5665 	{

  5666 	User::Panic(_L("SRSSNK Test"), 0);

  5667 	return iSinkDataTypeCode;

  5668 	}

  5670 void CMMFDummySink::EmptyBufferL(CMMFBuffer* /*aBuffer*/ , MDataSource* /*aSupplier*/, TMediaId /*aMediaId*/)

  5671 	{

  5672 	User::Panic(_L("SRSSNK Test"), 0);

  5673 	}

  5675 void CMMFDummySink::BufferFilledL(CMMFBuffer* aBuffer)

  5676 	{

  5677 	iBuffer = aBuffer;

  5679 	iFillCount++;

  5680 	if (iFillCount == iExpectedFillCount)

  5681 		iBufferFilledOk = ETrue;

  5683 	if ((iActiveScheduler != NULL) && iBufferFilledOk)

  5684 		CActiveScheduler::Stop();

  5685 	}

  5687 TInt CMMFDummySink::SendEventToClient(const TMMFEvent& aEvent)

  5688 	{

  5689 	iError = aEvent.iErrorCode;

  5690 	iErrorCount++;

  5692 	iFillCount++;

  5693 	if ((iActiveScheduler != NULL) && (iFillCount == iExpectedFillCount))

  5694 		CActiveScheduler::Stop();

  5696 	return 0;

  5697 	}

  5699 TBool CMMFDummySink::CanCreateSinkBuffer()

  5700 	{

  5701 	User::Panic(_L("SRSSNK Test"), 0);

  5702 	return EFalse;

  5703 	}

  5705 CMMFBuffer* CMMFDummySink::CreateSinkBufferL(TMediaId /*aMediaId*/, TBool& /*aReference*/)

  5706 	{

  5707 	User::Panic(_L("SRSSNK Test"), 0);

  5708 	return NULL;

  5709 	}

  5711 void CMMFDummySink::ConstructSinkL(const TDesC8& /*aInitData*/)

  5712 	{

  5713 	User::Panic(_L("SRSSNK Test"), 0);

  5714 	}

  5717 /**

  5718  *

  5719  * CTestStep_MMF_SRSSNK_U_0001 constructor

  5720  *

  5721  * @xxxx

  5722  *

  5723  */

  5724 CTestStep_MMF_SRSSNK_U_0001::CTestStep_MMF_SRSSNK_U_0001()

  5725 	{

  5726 	// store the name of this test case

  5727 	// this is the name that is used by the script file

  5728 	// Each test step initialises it's own name

  5729 	iTestStepName = _L("MM-MMF-SRSSNK-U-0001");

  5730 	}

  5732 /**

  5733  *

  5734  * CTestStep_MMF_SRSSNK_U_0001 destructor

  5735  *

  5736  * @xxxx

  5737  *

  5738  */

  5739 CTestStep_MMF_SRSSNK_U_0001::~CTestStep_MMF_SRSSNK_U_0001()

  5740 	{

  5741 	}

  5743 /**

  5744  *

  5745  * CTestStep_MMF_SRSSNK_U_0001

  5746  *

  5747  * Test creation/destruction of descriptor source.

  5748  *

  5749  * @xxxx

  5750  */

  5751 TVerdict CTestStep_MMF_SRSSNK_U_0001::DoTestStepL()

  5752 	{

  5753 	__MM_HEAP_MARK;

  5755 	// Create the actual descriptor source buffer.

  5756 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  5757 	TPtr8 dataPtr(dataDes->Des());

  5759 	// Set it's length.

  5760 	dataPtr.SetLength(KTestBufferSize);

  5762 	// Initialise the config data.

  5763 	TMMFDescriptorConfig configDes;

  5764 	configDes().iDes = &dataPtr;

  5765 	configDes().iDesThreadId = RThread().Id();

  5767 	// Attempt to create a new descriptor source.

  5768 	// Use a valid uid and configuration descriptor.

  5769 	// The test should be successful.

  5770 	TNewSourceTestStep testStep(KUidMmfDescriptorSource, configDes);

  5771 	DoTest(testStep, _L("Construct descriptor source"), KErrNone);

  5773 	// Create a descriptor source for use with the other tests.

  5774 	// Mark the heap to enable us to test for leaks within the source object.

  5775 	MDataSource* source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  5776 	CleanupDeletePushL(source);

  5778 	// Test that the source has been initialised correctly.

  5779 	// The test should be successful.

  5780 	TSourceTypeTestStep testStep2(source, KUidMmfDescriptorSource, KMMFFourCCCodeNULL, EFalse);

  5781 	DoTest(testStep2, _L("Descriptor source type"), KErrNone);

  5783 	// Test that the source cannot create a source buffer.

  5784 	// The test should be successful.

  5785 	TCanCreateSourceBufferTestStep testStep3(source, EFalse);

  5786 	DoTest(testStep3, _L("Descriptor CanCreateSourceBuffer"), KErrNone);

  5788 	// Test that the source cannot source sample convert.

  5789 	// The test should be successful.

  5790 	TSourceSampleConvertTestStep testStep4(source, EFalse);

  5791 	DoTest(testStep4, _L("Descriptor source SourceSampleConvert"), KErrNone);

  5793 	// Test that the clip is initialised correctly.

  5794 	CMMFClip *sourceClip = STATIC_CAST(CMMFClip*, source);

  5796 	// Test that the number of bytes free is what we would expect.

  5797 	// The test should be successful.

  5798 	TClipBytesFreeTestStep testStep5(sourceClip, KTestDataSize-KTestBufferSize);

  5799 	DoTest(testStep5, _L("Descriptor source BytesFree"), KErrNone);

  5801 	// Test that the size of the clip is what we would expect.

  5802 	// The test should be successful.

  5803 	TClipSizeTestStep testStep6(sourceClip, KTestBufferSize);

  5804 	DoTest(testStep6, _L("Descriptor source Size"), KErrNone);

  5806 	// Test that the size of the clip cannot be set.

  5807 	// The test should be successful.

  5808 	TClipSetSizeTestStep testStep7(sourceClip, ETrue);

  5809 	DoTest(testStep7, _L("Descriptor source SetSize"), KErrNone);

  5811 	// Attempt to delete the clip.

  5812 	// This test should fail, leaving with KErrNotSupported.

  5813 	TClipDeleteTestStep testStep8(sourceClip);

  5814 	DoTest(testStep8, _L("Descriptor source Delete"), KErrNotSupported);

  5816 	CleanupStack::PopAndDestroy(source);

  5818 	CleanupStack::PopAndDestroy(dataDes);

  5820 	__MM_HEAP_MARKEND;

  5821 	return iTestResult;

  5822 	}

  5824 /**

  5825  *

  5826  * CTestStep_MMF_SRSSNK_U_0002 constructor

  5827  *

  5828  * @xxxx

  5829  *

  5830  */

  5831 CTestStep_MMF_SRSSNK_U_0002::CTestStep_MMF_SRSSNK_U_0002()

  5832 	{

  5833 	// store the name of this test case

  5834 	// this is the name that is used by the script file

  5835 	// Each test step initialises it's own name

  5836 	iTestStepName = _L("MM-MMF-SRSSNK-U-0002");

  5837 	}

  5839 /**

  5840  *

  5841  * CTestStep_MMF_SRSSNK_U_0002 destructor

  5842  *

  5843  * @xxxx

  5844  *

  5845  */

  5846 CTestStep_MMF_SRSSNK_U_0002::~CTestStep_MMF_SRSSNK_U_0002()

  5847 	{

  5848 	}

  5850 /**

  5851  *

  5852  * CTestStep_MMF_SRSSNK_U_0002

  5853  *

  5854  * Attempt to create descriptor source using invalid config data.

  5855  *

  5856  * @xxxx

  5857  */

  5858 TVerdict CTestStep_MMF_SRSSNK_U_0002::DoTestStepL()

  5859 	{

  5860 	__MM_HEAP_MARK;

  5862 	TBool failed = EFalse;

  5864 	// Create the actual descriptor source buffer.

  5865 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  5866 	TPtr8 dataPtr(dataDes->Des());

  5868 	// Initialise config data.

  5869 	TMMFDescriptorConfig configDes;

  5870 	configDes.SetLength(0);

  5872 	// Test invalid uid and configuration descriptor.

  5873 	TNewSourceTestStep testStep(KNullUid, configDes);

  5874 	DoTest(testStep, _L("Construct descriptor source 0002.1"), KErrArgument);

  5875 	if (iTestResult != EPass)

  5876 		{

  5877 		INFO_PRINTF1(_L(" - 0002.1 failed"));

  5878 		failed = ETrue;

  5879 		iTestResult = EPass;

  5880 		}

  5882 	// Test invalid configuration descriptor. (Zero length)

  5883 	TNewSourceTestStep testStep2(KUidMmfDescriptorSource, configDes);

  5884 	DoTest(testStep2, _L("Construct descriptor source 0002.2"), KErrGeneral);

  5885 	if (iTestResult != EPass)

  5886 		{

  5887 		INFO_PRINTF1(_L(" - 0002.2 failed"));

  5888 		failed = ETrue;

  5889 		iTestResult = EPass;

  5890 		}

  5893 	// Test invalid configuration descriptor. (Filled with zeros)

  5894 	Mem::FillZ(CONST_CAST(TUint8*, dataPtr.Ptr()), KTestDataSize);

  5895 	TNewSourceTestStep testStep3(KUidMmfDescriptorSource, dataPtr);

  5896 	DoTest(testStep3, _L("Construct descriptor source 0002.3"), KErrGeneral);

  5897 	if (iTestResult != EPass)

  5898 		{

  5899 		INFO_PRINTF1(_L(" - 0002.3 failed"));

  5900 		failed = ETrue;

  5901 		iTestResult = EPass;

  5902 		}

  5905 	// Test invalid uid.

  5906 	const TUid KInvalidUid = { 0x00690069 };

  5907 	configDes().iDes = &dataDes;

  5908 	configDes().iDesThreadId = RThread().Id();

  5909 	configDes.SetLength(sizeof(TMMFDescriptorParams));

  5911 	TNewSourceTestStep testStep4(KInvalidUid, configDes);

  5912 	DoTest(testStep4, _L("Construct descriptor source 0002.4"), KErrNotFound);

  5913 	if (iTestResult != EPass)

  5914 		{

  5915 		INFO_PRINTF1(_L(" - 0002.4 failed"));

  5916 		failed = ETrue;

  5917 		iTestResult = EPass;

  5918 		}

  5921 	// Test valid uid, invalid descriptor.

  5922 	// Note using a thread ID of 0 behaves differently on streaming so this

  5923 	// test has been removed.

  5924 	// configDes().iDesThreadId = 0;

  5926 	// TNewSourceTestStep testStep5(KUidMmfDescriptorSource, configDes);

  5927 	// DoTest(testStep5, _L("Construct descriptor source 5"), KErrNotFound);

  5929 	// Test invalid (sink) uid.

  5930 	// Note that ECom has no way of validating that Uids are of the correct type,

  5931 	// so this test is removed. (It causes an unhandled exception)

  5932 	// TNewSourceTestStep testStep6(KUidMmfDescriptorSink, configDes);

  5933 	// DoTest(testStep6, _L("Construct descriptor source"), KErrNotFound);

  5935 	CleanupStack::PopAndDestroy(dataDes);

  5936 	__MM_HEAP_MARKEND;

  5938 	return (failed ? EFail : EPass);

  5939 	}

  5941 /**

  5942  *

  5943  * CTestStep_MMF_SRSSNK_U_0003 constructor

  5944  *

  5945  * @xxxx

  5946  *

  5947  */

  5948 CTestStep_MMF_SRSSNK_U_0003::CTestStep_MMF_SRSSNK_U_0003()

  5949 	{

  5950 	// store the name of this test case

  5951 	// this is the name that is used by the script file

  5952 	// Each test step initialises it's own name

  5953 	iTestStepName = _L("MM-MMF-SRSSNK-U-0003");

  5954 	}

  5956 /**

  5957  *

  5958  * CTestStep_MMF_SRSSNK_U_0003 destructor

  5959  *

  5960  * @xxxx

  5961  *

  5962  */

  5963 CTestStep_MMF_SRSSNK_U_0003::~CTestStep_MMF_SRSSNK_U_0003()

  5964 	{

  5965 	}

  5967 /**

  5968  *

  5969  * CTestStep_MMF_SRSSNK_U_0003

  5970  *

  5971  * Test creation/destruction of descriptor sink.

  5972  *

  5973  * @xxxx

  5974  */

  5975 TVerdict CTestStep_MMF_SRSSNK_U_0003::DoTestStepL()

  5976 	{

  5977 	__MM_HEAP_MARK;

  5979 	// Create sink buffer.

  5980 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  5981 	TPtr8 dataPtr(dataDes->Des());

  5983 	// Set it's length.

  5984 	dataPtr.SetLength(KTestBufferSize);

  5986 	// Initialise config data.

  5987 	TMMFDescriptorConfig configDes;

  5988 	configDes().iDes = &dataPtr;

  5989 	configDes().iDesThreadId = RThread().Id();

  5991 	// Test valid uid and configuration descriptor.

  5992 	TNewSinkTestStep testStep(KUidMmfDescriptorSink, configDes);

  5993 	DoTest(testStep, _L("Construct descriptor sink"), KErrNone);

  5995 	// Create a descriptor sink.

  5996 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfDescriptorSink, configDes);

  5997 	CleanupDeletePushL(sink);

  5999 	// Test that the sink is initialised correctly.

  6000 	TSinkTypeTestStep testStep2(sink, KUidMmfDescriptorSink, KMMFFourCCCodeNULL, EFalse);

  6001 	DoTest(testStep2, _L("Descriptor sink type"), KErrNone);

  6003 	TCanCreateSinkBufferTestStep testStep3(sink, EFalse);

  6004 	DoTest(testStep3, _L("Descriptor sink CanCreateSinkBuffer"), KErrNone);

  6006 	// Test that the clip is initialised correctly.

  6007 	CMMFClip *sinkClip = STATIC_CAST(CMMFClip*, sink);

  6008 	TClipBytesFreeTestStep testStep4(sinkClip, KTestDataSize-KTestBufferSize);

  6009 	DoTest(testStep4, _L("Descriptor sink BytesFree"), KErrNone);

  6011 	TClipSizeTestStep testStep5(sinkClip, KTestBufferSize);

  6012 	DoTest(testStep5, _L("Descriptor sink Size"), KErrNone);

  6014 	TClipSetSizeTestStep testStep6(sinkClip, ETrue);

  6015 	DoTest(testStep6, _L("Descriptor sink SetSize"), KErrNone);

  6017 	TClipDeleteTestStep testStep7(sinkClip);

  6018 	DoTest(testStep7, _L("Descriptor sink Delete"), KErrNotSupported);

  6020 	CleanupStack::PopAndDestroy(sink);

  6022 	CleanupStack::PopAndDestroy(dataDes);

  6023 	__MM_HEAP_MARKEND;

  6024 	return iTestResult;

  6025 	}

  6027 /**

  6028  *

  6029  * CTestStep_MMF_SRSSNK_U_0004 constructor

  6030  *

  6031  * @xxxx

  6032  *

  6033  */

  6034 CTestStep_MMF_SRSSNK_U_0004::CTestStep_MMF_SRSSNK_U_0004()

  6035 	{

  6036 	// store the name of this test case

  6037 	// this is the name that is used by the script file

  6038 	// Each test step initialises it's own name

  6039 	iTestStepName = _L("MM-MMF-SRSSNK-U-0004");

  6040 	}

  6042 /**

  6043  *

  6044  * CTestStep_MMF_SRSSNK_U_0004 destructor

  6045  *

  6046  * @xxxx

  6047  *

  6048  */

  6049 CTestStep_MMF_SRSSNK_U_0004::~CTestStep_MMF_SRSSNK_U_0004()

  6050 	{

  6051 	}

  6053 /**

  6054  *

  6055  * CTestStep_MMF_SRSSNK_U_0004

  6056  *

  6057  * Attempt to create descriptor sink using invalid config data.

  6058  *

  6059  * @xxxx

  6060  */

  6061 TVerdict CTestStep_MMF_SRSSNK_U_0004::DoTestStepL()

  6062 	{

  6063 	__MM_HEAP_MARK;

  6065 	// Create sink buffer.

  6066 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6067 	TPtr8 dataPtr(dataDes->Des());

  6069 	// Initialise config data.

  6070 	TMMFDescriptorConfig configDes;

  6071 	configDes.SetLength(0);

  6073 	// Test invalid uid and configuration descriptor.

  6074 	TNewSinkTestStep testStep(KNullUid, configDes);

  6075 	DoTest(testStep, _L("Construct descriptor sink 1"), KErrArgument);

  6077 	// Test invalid configuration descriptor. (Zero length)

  6078 	TNewSinkTestStep testStep2(KUidMmfDescriptorSink, configDes);

  6079 	DoTest(testStep2, _L("Construct descriptor sink 2"), KErrGeneral);

  6081 	// Test invalid configuration descriptor. (Filled with zeros)

  6082 	Mem::FillZ(CONST_CAST(TUint8*, dataPtr.Ptr()), KTestDataSize);

  6083 	TNewSinkTestStep testStep3(KUidMmfDescriptorSink, dataPtr);

  6084 	DoTest(testStep3, _L("Construct descriptor sink 3"), KErrGeneral);

  6086 	// Test invalid uid.

  6087 	const TUid KInvalidUid = { 0x00690069 };

  6088 	configDes().iDes = &dataDes;

  6089 	configDes().iDesThreadId = RThread().Id();

  6090 	configDes.SetLength(sizeof(TMMFDescriptorParams));

  6092 	TNewSinkTestStep testStep4(KInvalidUid, configDes);

  6093 	DoTest(testStep4, _L("Construct descriptor sink 4"), KErrNotFound);

  6095 	// Test valid uid, invalid descriptor.

  6096 	configDes().iDesThreadId = (TUint) -1;

  6097 	TNewSinkTestStep testStep5(KUidMmfDescriptorSink, configDes);

  6098 	DoTest(testStep5, _L("Construct descriptor sink 5"), KErrNotFound);

  6100 	// Test invalid (source) uid.

  6101 	// Note that ECom has no way of validating that Uids are of the correct type,

  6102 	// so this test is removed. (It causes an unhandled exception)

  6103 	// TNewSinkTestStep testStep6(KUidMmfDescriptorSource, configDes);

  6104 	// DoTest(testStep6, _L("Construct descriptor sink"), KErrNotFound);

  6106 	CleanupStack::PopAndDestroy(dataDes);

  6107 	__MM_HEAP_MARKEND;

  6108 	return iTestResult;

  6109 	}

  6111 /**

  6112  *

  6113  * CTestStep_MMF_SRSSNK_U_0005 constructor

  6114  *

  6115  * @xxxx

  6116  *

  6117  */

  6118 CTestStep_MMF_SRSSNK_U_0005::CTestStep_MMF_SRSSNK_U_0005()

  6119 	{

  6120 	// store the name of this test case

  6121 	// this is the name that is used by the script file

  6122 	// Each test step initialises it's own name

  6123 	iTestStepName = _L("MM-MMF-SRSSNK-U-0005");

  6124 	}

  6126 /**

  6127  *

  6128  * CTestStep_MMF_SRSSNK_U_0005 destructor

  6129  *

  6130  * @xxxx

  6131  *

  6132  */

  6133 CTestStep_MMF_SRSSNK_U_0005::~CTestStep_MMF_SRSSNK_U_0005()

  6134 	{

  6135 	}

  6137 /**

  6138  *

  6139  * CTestStep_MMF_SRSSNK_U_0005

  6140  *

  6141  * Functional test of descriptor source.

  6142  * Misc. functions test.

  6143  *

  6144  * @xxxx

  6145  */

  6146 TVerdict CTestStep_MMF_SRSSNK_U_0005::DoTestStepL()

  6147 	{

  6148 	__MM_HEAP_MARK;

  6149 	// Create source buffer.

  6150 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6151 	TPtr8 dataPtr(dataDes->Des());

  6153 	// Initialise config data.

  6154 	TMMFDescriptorConfig configDes;

  6155 	configDes().iDes = &dataPtr;

  6156 	configDes().iDesThreadId = RThread().Id();

  6158 	// Create a dummy buffer.

  6159 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  6160 	CleanupStack::PushL(validBuffer);

  6162 	// Create a dummy sink.

  6163 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  6164 	CleanupStack::PushL(dummySink);

  6166 	// Create a descriptor source.

  6167 	MDataSource* source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6168 	CleanupDeletePushL(source);

  6170 	// Test create source buffer.

  6171 	TCreateSourceBuffer1TestStep testStep(ESourceTypeDes, dummySink, KUidMmfDescriptorBuffer, ETrue);

  6172 	DoTest(testStep, _L("Descriptor source CreateSourceBuffer1"), KErrNotSupported);

  6174 	TCreateSourceBuffer2TestStep testStep2(ESourceTypeDes, dummySink, validBuffer, KUidMmfDescriptorBuffer, ETrue);

  6175 	DoTest(testStep2, _L("Descriptor source CreateSourceBuffer2"), KErrNotSupported);

  6177 	// Test default base class fns. (These should all do nothing)

  6178 	TSourceThreadLogonTestStep testStep3(source, dummySink);

  6179 	DoTest(testStep3, _L("Descriptor source SourceThreadLogon"), KErrNone);

  6181 	TNegotiateSourceTestStep testStep4(source, dummySink);

  6182 	DoTest(testStep4, _L("Descriptor source NegotiateSourceL"), KErrNone);

  6184 	source->SourcePrimeL();

  6185 	source->SourcePlayL();

  6186 	source->SourcePauseL();

  6187 	source->SourceStopL();

  6189 	TMMFPrioritySettings prioritySettings;

  6190 	source->SetSourcePrioritySettings(prioritySettings);

  6192 	CleanupStack::PopAndDestroy(source);

  6195 	CleanupStack::PopAndDestroy(3, dataDes); // dummySink, validBuffer, dataDes

  6196 	__MM_HEAP_MARKEND;

  6198 	return iTestResult;

  6199 	}

  6201 /**

  6202  *

  6203  * CTestStep_MMF_SRSSNK_U_0006 constructor

  6204  *

  6205  * @xxxx

  6206  *

  6207  */

  6208 CTestStep_MMF_SRSSNK_U_0006::CTestStep_MMF_SRSSNK_U_0006()

  6209 	{

  6210 	// store the name of this test case

  6211 	// this is the name that is used by the script file

  6212 	// Each test step initialises it's own name

  6213 	iTestStepName = _L("MM-MMF-SRSSNK-U-0006");

  6214 	}

  6216 /**

  6217  *

  6218  * CTestStep_MMF_SRSSNK_U_0006 destructor

  6219  *

  6220  * @xxxx

  6221  *

  6222  */

  6223 CTestStep_MMF_SRSSNK_U_0006::~CTestStep_MMF_SRSSNK_U_0006()

  6224 	{

  6225 	}

  6227 /**

  6228  *

  6229  * CTestStep_MMF_SRSSNK_U_0006

  6230  *

  6231  * Functional test of descriptor source.

  6232  * FillBufferL() test.

  6233  *

  6234  * @xxxx

  6235  */

  6236 TVerdict CTestStep_MMF_SRSSNK_U_0006::DoTestStepL()

  6237 	{

  6238 	__MM_HEAP_MARK;

  6239 	// Create source buffer.

  6240 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6241 	TPtr8 dataPtr(dataDes->Des());

  6243 	// Set it's length

  6244 	dataPtr.SetLength(KTestDataSize);

  6246 	// Randomise source buffer.

  6247 	TTime seedTime;

  6248 	seedTime.UniversalTime();

  6249 	TInt64 seed = seedTime.Int64();

  6251 	TInt i;

  6252 	for (i = 0 ; i<KTestDataSize ; i++)

  6253 		dataPtr[i] = TUint8(Math::Rand(seed));

  6255 	// Initialise config data.

  6256 	TMMFDescriptorConfig configDes;

  6257 	configDes().iDes = &dataPtr;

  6258 	configDes().iDesThreadId = RThread().Id();

  6260 	// Create zero length buffer.

  6261 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  6262 	CleanupStack::PushL(zeroBuffer);

  6264 	// Create big buffer.

  6265 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

  6266 	CleanupStack::PushL(bigBuffer);

  6268 	// Create valid buffer.

  6269 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  6270 	CleanupStack::PushL(validBuffer);

  6272 	// Create dummy sink.

  6273 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  6274 	CleanupStack::PushL(dummySink);

  6276 	// Create a descriptor source.

  6277 	MDataSource* source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6278 	CleanupDeletePushL(source);

  6280 	// Create test (invalid) buffer.

  6281 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  6282 	CleanupStack::PushL(testBuffer);

  6284 	// Test invalid FillBufferL.

  6285 	TFillBufferTestStep testStep(source, testBuffer, dummySink, dataPtr);

  6286 	DoTest(testStep, _L("Descriptor source FillBufferL"), KErrNotSupported);

  6287 	CleanupStack::PopAndDestroy(testBuffer);

  6289 	// Test valid fill.

  6290 	TFillBufferTestStep testStep2(source, validBuffer, dummySink, dataPtr, KTestBufferSize);

  6291 	DoTest(testStep2, _L("Descriptor source FillBufferL"), KErrNone);

  6293 	CleanupStack::PopAndDestroy(source);

  6295 	source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6296 	CleanupDeletePushL(source);

  6298 	// Test complete fill.

  6299 	TFillBufferTestStep testStep3(source, validBuffer, dummySink, dataPtr);

  6301 	const TUint8* baseDataPtr = dataPtr.Ptr();

  6302 	const TUint8* sourcePtr = baseDataPtr;

  6303 	TInt bufferSize;

  6304 	do

  6305 		{

  6306 		testStep3.SetReadLength(Min(KTestBufferSize, KTestDataSize - (sourcePtr-baseDataPtr)));

  6307 		DoTestStep(testStep3, _L("Descriptor source FillBufferL"), KErrNone);

  6309 		bufferSize = validBuffer->BufferSize();

  6310 		sourcePtr += bufferSize;

  6311 		} while (bufferSize == KTestBufferSize);

  6313 	CleanupStack::PopAndDestroy(source);

  6315 	source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6316 	CleanupDeletePushL(source);

  6318 	// Test complete fill with alloc fail.

  6319 	TFillBufferTestStep testStep4(source, validBuffer, dummySink, dataPtr);

  6321 	sourcePtr = baseDataPtr;

  6322 	do

  6323 		{

  6324 		testStep4.SetReadLength(Min(KTestBufferSize, KTestDataSize - (sourcePtr-baseDataPtr)));

  6325 		DoTestStepWithAllocFail(testStep4, _L("Descriptor source FillBufferL"), KErrNone);

  6327 		bufferSize = validBuffer->BufferSize();

  6328 		sourcePtr += bufferSize;

  6329 		} while (bufferSize == KTestBufferSize);

  6331 	// Test additional fill request.

  6332 	TFillBufferTestStep testStep5(source, validBuffer, dummySink, dataPtr);

  6333 	DoTest(testStep5, _L("Descriptor source FillBufferL"), KErrNone);

  6335 	CleanupStack::PopAndDestroy(source);

  6337 	source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6338 	CleanupDeletePushL(source);

  6340 	// Test zero length read.

  6341 	TFillBufferTestStep testStep6(source, zeroBuffer, dummySink, dataPtr);

  6342 	DoTest(testStep6, _L("Descriptor source FillBufferL"), KErrNone);

  6344 	// Test over size read.

  6345 	TFillBufferTestStep testStep7(source, bigBuffer, dummySink, dataPtr, KTestDataSize);

  6346 	DoTestStep(testStep7, _L("Descriptor source FillBufferL"), KErrNone);

  6348 	CleanupStack::PopAndDestroy(source);

  6350 	source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6351 	CleanupDeletePushL(source);

  6353 	testStep7.SetPosition(0);

  6354 	DoTestStepWithAllocFail(testStep7, _L("Descriptor source FillBufferL"), KErrNone);

  6356 	CleanupStack::PopAndDestroy(5, zeroBuffer); // source, dummySink, validBuffer, bigBuffer, zeroBuffer

  6358 	CleanupStack::PopAndDestroy(dataDes); // dataDes

  6360 	__MM_HEAP_MARKEND;

  6361 	return iTestResult;

  6362 	}

  6364 /**

  6365  *

  6366  * CTestStep_MMF_SRSSNK_U_0007 constructor

  6367  *

  6368  * @xxxx

  6369  *

  6370  */

  6372 CTestStep_MMF_SRSSNK_U_0007::CTestStep_MMF_SRSSNK_U_0007()

  6373 : CTestStep_MMF_SRSSNK(EFalse)

  6374 	{

  6375 	// store the name of this test case

  6376 	// this is the name that is used by the script file

  6377 	// Each test step initialises it's own name

  6378 	iTestStepName = _L("MM-MMF-SRSSNK-U-0007");

  6379 	}

  6381 /**

  6382  *

  6383  * CTestStep_MMF_SRSSNK_U_0007 destructor

  6384  *

  6385  * @xxxx

  6386  *

  6387  */

  6388 CTestStep_MMF_SRSSNK_U_0007::~CTestStep_MMF_SRSSNK_U_0007()

  6389 	{

  6390 	}

  6392 /**

  6393  *

  6394  * CTestStep_MMF_SRSSNK_U_0007

  6395  *

  6396  * Functional test of descriptor source.

  6397  * BufferEmptiedL() panic test.

  6398  *

  6399  * @xxxx

  6400  */

  6401 TVerdict CTestStep_MMF_SRSSNK_U_0007::DoTestStepL()

  6402 	{

  6403 	__MM_HEAP_MARK;

  6404 	// This test fails if running a debug StdSourcesAndSinks dll.

  6405 	// So only perform the test on target.

  6407 	// Create source buffer.

  6408 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6409 	TPtr8 dataPtr(dataDes->Des());

  6411 	// Initialise config data.

  6412 	TMMFDescriptorConfig configDes;

  6413 	configDes().iDes = &dataPtr;

  6414 	configDes().iDesThreadId = RThread().Id();

  6416 	// Create valid buffer.

  6417 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  6418 	CleanupStack::PushL(validBuffer);

  6420 	// Create source descriptor.

  6421 	MDataSource* source = MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes);

  6422 	CleanupDeletePushL(source);

  6424 	// Test BufferEmptiedL

  6425 	source->BufferEmptiedL(validBuffer);

  6427 	CleanupStack::PopAndDestroy(2, validBuffer); // source, validBuffer

  6429 	CleanupStack::PopAndDestroy(dataDes);

  6431 	__MM_HEAP_MARKEND;

  6432 	return iTestResult;

  6433 	}

  6435 /**

  6436  *

  6437  * CTestStep_MMF_SRSSNK_U_0008 constructor

  6438  *

  6439  * @xxxx

  6440  *

  6441  */

  6442 CTestStep_MMF_SRSSNK_U_0008::CTestStep_MMF_SRSSNK_U_0008()

  6443 	{

  6444 	// store the name of this test case

  6445 	// this is the name that is used by the script file

  6446 	// Each test step initialises it's own name

  6447 	iTestStepName = _L("MM-MMF-SRSSNK-U-0008");

  6448 	}

  6450 /**

  6451  *

  6452  * CTestStep_MMF_SRSSNK_U_0008 destructor

  6453  *

  6454  * @xxxx

  6455  *

  6456  */

  6457 CTestStep_MMF_SRSSNK_U_0008::~CTestStep_MMF_SRSSNK_U_0008()

  6458 	{

  6459 	}

  6461 /**

  6462  *

  6463  * CTestStep_MMF_SRSSNK_U_0008

  6464  *

  6465  * Functional test of descriptor source.

  6466  * ReadBufferL() test.

  6467  *

  6468  * @xxxx

  6469  */

  6470 TVerdict CTestStep_MMF_SRSSNK_U_0008::DoTestStepL()

  6471 	{

  6472 	__MM_HEAP_MARK;

  6473 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6474 	TPtr8 dataPtr(dataDes->Des());

  6476 	// Set it's length.

  6477 	dataPtr.SetLength(KTestDataSize);

  6479 	TTime seedTime;

  6480 	seedTime.UniversalTime();

  6481 	TInt64 seed = seedTime.Int64();

  6482 	for (TInt i = 0 ; i<KTestDataSize ; i++)

  6483 		dataPtr[i] = TUint8(Math::Rand(seed));

  6485 	// Initialise config data.

  6486 	TMMFDescriptorConfig configDes;

  6487 	configDes().iDes = &dataPtr;

  6488 	configDes().iDesThreadId = RThread().Id();

  6490 	// Create zero length buffer.

  6491 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  6492 	CleanupStack::PushL(zeroBuffer);

  6494 	// Create big buffer.

  6495 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

  6496 	CleanupStack::PushL(bigBuffer);

  6498 	// Create valid buffer.

  6499 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  6500 	CleanupStack::PushL(validBuffer);

  6502 	// Create dummy sink.

  6503 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  6504 	CleanupStack::PushL(dummySink);

  6506 	// Create source descriptor.

  6507 	CMMFClip* source = STATIC_CAST(CMMFClip*, MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes));

  6508 	CleanupStack::PushL(source);

  6510 	// Create test (invalid) buffer.

  6511 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  6512 	CleanupStack::PushL(testBuffer);

  6514 	// Test ReadBufferL (these tests should fail)

  6515 	TClipReadBufferTestStep testStep(source, testBuffer, 0, dummySink, dataPtr);

  6516 	DoTest(testStep, _L("Descriptor source ReadBufferL"), KErrNotSupported);

  6518 	TClipReadBuffer2TestStep testStep2(source, testBuffer, 0, dummySink, dataPtr, KTestBufferSize);

  6519 	DoTest(testStep2, _L("Descriptor source ReadBufferL"), KErrNotSupported);

  6521 	TClipReadBuffer3TestStep testStep3(source, testBuffer, 0, dataPtr, KTestBufferSize);

  6522 	DoTest(testStep3, _L("Descriptor source ReadBufferL"), KErrNotSupported);

  6523 	CleanupStack::PopAndDestroy(testBuffer);

  6525 	// Test reading from the beginning, middle, and end of the descriptor.

  6526 	TClipReadBufferTestStep testStep4(source, validBuffer, 0, dummySink, dataPtr, KTestReadSize);

  6527 	DoTest(testStep4, _L("Descriptor source ReadBufferL"), KErrNone);

  6529 	testStep4.SetPosition(1);

  6530 	DoTest(testStep4, _L("Descriptor source ReadBufferL"), KErrNone);

  6532 	testStep4.SetPosition(KTestDataSize/2);

  6533 	DoTest(testStep4, _L("Descriptor source ReadBufferL"), KErrNone);

  6535 	testStep4.SetPosition(KTestDataSize/2 + 1);

  6536 	DoTest(testStep4, _L("Descriptor source ReadBufferL"), KErrNone);

  6538 	TClipReadBuffer4TestStep testStep5(source, validBuffer, KTestDataSize - 10, dummySink, dataPtr, KTestReadSize);

  6539 	testStep5.SetExpectedReadLength(10);

  6540 	DoTest(testStep5, _L("Descriptor source ReadBufferL"), KErrNone);

  6542 	testStep5.SetPosition(KTestDataSize);

  6543 	testStep5.SetExpectedReadLength(0);

  6544 	DoTest(testStep5, _L("Descriptor source ReadBufferL"), KErrNone);

  6546 	testStep5.SetPosition(KTestDataSize + 2);

  6547 	DoTest(testStep5, _L("Descriptor source ReadBufferL"), KErrNone);

  6549 	// Attempt to read nothing.

  6550 	TClipReadBufferTestStep testStep6(source, validBuffer, 0, dummySink, dataPtr);

  6551 	DoTest(testStep6, _L("Descriptor source ReadBufferL"), KErrNone);

  6553 	// Attempt to read more data than can fit in the buffer.

  6554 	testStep6.SetReadLength(KTestOverReadSize);

  6555 	DoTest(testStep6, _L("Descriptor source ReadBufferL"), KErrOverflow);

  6557 	// Attempt to read into a zero length buffer.

  6558 	TClipReadBufferTestStep testStep7(source, zeroBuffer, 0, dummySink, dataPtr);

  6559 	DoTest(testStep7, _L("Descriptor source ReadBufferL"), KErrNone);

  6561 	// Attempt to read more data than present in the source.

  6562 	TClipReadBuffer4TestStep testStep8(source, bigBuffer, 0, dummySink, dataPtr, KTestOverDataSize);

  6563 	testStep8.SetExpectedReadLength(KTestDataSize);

  6564 	DoTest(testStep8, _L("File source ReadBufferL"), KErrNone);

  6566 	// Repeat reads without supplying the length to read.

  6567 	TClipReadBuffer2TestStep testStep9(source, validBuffer, 0, dummySink, dataPtr, KTestBufferSize);

  6568 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6570 	testStep9.SetPosition(1);

  6571 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6573 	testStep9.SetPosition(KTestDataSize/2);

  6574 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6576 	testStep9.SetPosition(KTestDataSize/2 + 1);

  6577 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6579 	testStep9.SetPosition(KTestDataSize - 10);

  6580 	testStep9.SetReadLength(10);

  6581 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6583 	testStep9.SetPosition(KTestDataSize);

  6584 	testStep9.SetReadLength(0);

  6585 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6587 	testStep9.SetPosition(KTestDataSize + 2);

  6588 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrNone);

  6590 	TClipReadBuffer2TestStep testStep10(source, zeroBuffer, 0, dummySink, dataPtr, 0);

  6591 	DoTest(testStep10, _L("Descriptor source ReadBufferL"), KErrNone);

  6593 	TClipReadBuffer2TestStep testStep11(source, bigBuffer, 0, dummySink, dataPtr, KTestDataSize);

  6594 	DoTest(testStep11, _L("Descriptor source ReadBufferL"), KErrNone);

  6596 	// Repeat reads without supplying the length, or a sink.

  6597 	TClipReadBuffer3TestStep testStep12(source, validBuffer, 0, dataPtr, KTestBufferSize);

  6598 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6600 	testStep12.SetPosition(1);

  6601 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6603 	testStep12.SetPosition(KTestDataSize/2);

  6604 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6606 	testStep12.SetPosition(KTestDataSize/2 + 1);

  6607 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6609 	testStep12.SetPosition(KTestDataSize - 10);

  6610 	testStep12.SetReadLength(10);

  6611 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6613 	testStep12.SetPosition(KTestDataSize);

  6614 	testStep12.SetReadLength(0);

  6615 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6617 	testStep12.SetPosition(KTestDataSize + 2);

  6618 	DoTest(testStep12, _L("Descriptor source ReadBufferL"), KErrNone);

  6620 	TClipReadBuffer3TestStep testStep13(source, zeroBuffer, 0, dataPtr, 0);

  6621 	DoTest(testStep13, _L("Descriptor source ReadBufferL"), KErrNone);

  6623 	TClipReadBuffer3TestStep testStep14(source, bigBuffer, 0, dataPtr, KTestDataSize);

  6624 	DoTest(testStep14, _L("Descriptor source ReadBufferL"), KErrNone);

  6626 	CleanupStack::PopAndDestroy(5, zeroBuffer); // source, dummySink, validBuffer, bigBuffer, zeroBuffer

  6628 	CleanupStack::PopAndDestroy(dataDes); // dataDes

  6630 	__MM_HEAP_MARKEND;

  6631 	return iTestResult;

  6632 	}

  6634 /**

  6635  *

  6636  * CTestStep_MMF_SRSSNK_U_0009 constructor

  6637  *

  6638  * @xxxx

  6639  *

  6640  */

  6641 CTestStep_MMF_SRSSNK_U_0009::CTestStep_MMF_SRSSNK_U_0009()

  6642 	{

  6643 	// store the name of this test case

  6644 	// this is the name that is used by the script file

  6645 	// Each test step initialises it's own name

  6646 	iTestStepName = _L("MM-MMF-SRSSNK-U-0009");

  6647 	}

  6649 /**

  6650  *

  6651  * CTestStep_MMF_SRSSNK_U_0009 destructor

  6652  *

  6653  * @xxxx

  6654  *

  6655  */

  6657 CTestStep_MMF_SRSSNK_U_0009::~CTestStep_MMF_SRSSNK_U_0009()

  6658 	{

  6659 	}

  6661 /**

  6662  *

  6663  * CTestStep_MMF_SRSSNK_U_0009

  6664  *

  6665  * Functional test of descriptor source.

  6666  * Source custom commands test.

  6667  *

  6668  * @xxxx

  6669  */

  6670 TVerdict CTestStep_MMF_SRSSNK_U_0009::DoTestStepL()

  6671 	{

  6672 	__MM_HEAP_MARK;

  6674 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6675 	TPtr8 dataPtr(dataDes->Des());

  6677 	// Initialise config data.

  6678 	TMMFDescriptorConfig configDes;

  6679 	configDes().iDes = &dataPtr;

  6680 	configDes().iDesThreadId = RThread().Id();

  6682 	TUid testControllerUid = { KMmfTestControllerUid };

  6683 	RMMFController dummyController;

  6684 	TMMFPrioritySettings prioritySettings;

  6685 	TMMFMessageDestinationPckg destination;

  6687 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

  6688 	CleanupClosePushL(dummyController);

  6690 	TBuf8<1> dummyArgs;

  6691 	User::LeaveIfError(dummyController.AddDataSource(KUidMmfDescriptorSource, configDes));

  6692 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSource, dummyArgs, dummyArgs);

  6693 	if (err != KErrNotSupported)

  6694 		{

  6695 		INFO_PRINTF2(_L("Descriptor source SourceCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

  6696 		iTestResult = EFail;

  6697 		}

  6699 	CleanupStack::PopAndDestroy(); // dummyController

  6701 	CleanupStack::PopAndDestroy(dataDes);

  6703 	__MM_HEAP_MARKEND;

  6704 	return iTestResult;

  6705 	}

  6708 /**

  6709  *

  6710  * CTestStep_MMF_SRSSNK_U_0010 constructor

  6711  *

  6712  * @xxxx

  6713  *

  6714  */

  6715 CTestStep_MMF_SRSSNK_U_0010::CTestStep_MMF_SRSSNK_U_0010()

  6716 	{

  6717 	// store the name of this test case

  6718 	// this is the name that is used by the script file

  6719 	// Each test step initialises it's own name

  6720 	iTestStepName = _L("MM-MMF-SRSSNK-U-0010");

  6721 	}

  6723 /**

  6724  *

  6725  * CTestStep_MMF_SRSSNK_U_0010 destructor

  6726  *

  6727  * @xxxx

  6728  *

  6729  */

  6731 CTestStep_MMF_SRSSNK_U_0010::~CTestStep_MMF_SRSSNK_U_0010()

  6732 	{

  6733 	}

  6735 /**

  6736  *

  6737  * CTestStep_MMF_SRSSNK_U_0010

  6738  *

  6739  * Functional test of descriptor sink.

  6740  * Misc. functions test.

  6741  *

  6742  * @xxxx

  6743  */

  6744 TVerdict CTestStep_MMF_SRSSNK_U_0010::DoTestStepL()

  6745 	{

  6746 	__MM_HEAP_MARK;

  6748 	// Create sink buffer.

  6749 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6750 	TPtr8 dataPtr(dataDes->Des());

  6752 	// Initialise config data.

  6753 	TMMFDescriptorConfig configDes;

  6754 	configDes().iDes = &dataPtr;

  6755 	configDes().iDesThreadId = RThread().Id();

  6757 	// Create a dummy sink.

  6758 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  6759 	CleanupStack::PushL(dummySource);

  6761 	// Create desciptor sink.

  6762 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfDescriptorSink, configDes);

  6763 	CleanupDeletePushL(sink);

  6765 	// Test create sink buffer.

  6766 	TCreateSinkBufferTestStep0 testStep(sink, KUidMmfDescriptorBuffer, ETrue, NULL);

  6767 	DoTest(testStep, _L("Descriptor sink CreateSinkBuffer"), KErrNotSupported);

  6769 	// Test default base class fns. (These should all do nothing)

  6770 	TSinkThreadLogonTestStep testStep2(sink, dummySource);

  6771 	DoTest(testStep2, _L("Descriptor sink SinkThreadLogon"), KErrNone);

  6773 	TNegotiateTestStep testStep3(sink, dummySource);

  6774 	DoTest(testStep3, _L("Descriptor sink NegotiateL"), KErrNone);

  6776 	sink->SinkPrimeL();

  6777 	sink->SinkPlayL();

  6778 	sink->SinkPauseL();

  6779 	sink->SinkStopL();

  6781 	TMMFPrioritySettings prioritySettings;

  6782 	sink->SetSinkPrioritySettings(prioritySettings);

  6784 	CleanupStack::PopAndDestroy(sink);

  6786 	CleanupStack::PopAndDestroy(2, dataDes); // dummySource, dataDes

  6788 	__MM_HEAP_MARKEND;

  6789 	return iTestResult;

  6790 	}

  6792 /**

  6793  *

  6794  * CTestStep_MMF_SRSSNK_U_0011 constructor

  6795  *

  6796  * @xxxx

  6797  *

  6798  */

  6799 CTestStep_MMF_SRSSNK_U_0011::CTestStep_MMF_SRSSNK_U_0011()

  6800 	{

  6801 	// store the name of this test case

  6802 	// this is the name that is used by the script file

  6803 	// Each test step initialises it's own name

  6804 	iTestStepName = _L("MM-MMF-SRSSNK-U-0011");

  6805 	}

  6807 /**

  6808  *

  6809  * CTestStep_MMF_SRSSNK_U_0011 destructor

  6810  *

  6811  * @xxxx

  6812  *

  6813  */

  6814 CTestStep_MMF_SRSSNK_U_0011::~CTestStep_MMF_SRSSNK_U_0011()

  6815 	{

  6816 	}

  6818 /**

  6819  *

  6820  * CTestStep_MMF_SRSSNK_U_0011

  6821  *

  6822  * Functional test of descriptor sink.

  6823  * EmptyBufferL() test.

  6824  *

  6825  * @xxxx

  6826  */

  6827 TVerdict CTestStep_MMF_SRSSNK_U_0011::DoTestStepL()

  6828 	{

  6829 	__MM_HEAP_MARK;

  6831 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  6832 	TPtr8 dataPtr(dataDes->Des());

  6833 	TUint8* baseDataPtr = CONST_CAST(TUint8*, dataPtr.Ptr());

  6835 	HBufC8* copyOfDataDes = HBufC8::NewLC(KTestDataSize);

  6836 	TPtr8 copyOfDataPtr(copyOfDataDes->Des());

  6838 	// Randomise the data.

  6839 	TTime seedTime;

  6840 	seedTime.UniversalTime();

  6841 	TInt64 seed = seedTime.Int64();

  6842 	for (TInt i = 0 ; i<KTestDataSize ; i++)

  6843 		baseDataPtr[i] = TUint8(Math::Rand(seed));

  6844 	Mem::Copy(CONST_CAST(TUint8*, copyOfDataPtr.Ptr()), baseDataPtr, KTestDataSize);

  6846 	// Initialise config data.

  6847 	TMMFDescriptorConfig configDes;

  6848 	configDes().iDes = &dataPtr;

  6849 	configDes().iDesThreadId = RThread().Id();

  6851 	// Create zero length buffer.

  6852 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  6853 	CleanupStack::PushL(zeroBuffer);

  6855 	// Create big buffer.

  6856 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

  6857 	CleanupStack::PushL(bigBuffer);

  6859 	// Set the length to write.

  6860 	bigBuffer->Data().SetLength(KTestOverDataSize);

  6862 	// Create a valid buffer.

  6863 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  6864 	CleanupStack::PushL(validBuffer);

  6866 	// Set the length to write.

  6867 	validBuffer->Data().SetLength(KTestWriteSize);

  6869 	// Create descriptor sink.

  6870 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfDescriptorSink, configDes);

  6871 	CleanupDeletePushL(sink);

  6873 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  6874 	CleanupStack::PushL(dummySource);

  6876 	// Create test (invalid) buffer.

  6877 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  6878 	CleanupStack::PushL(testBuffer);

  6880 	// Test invalid EmptyBufferL.

  6881 	TEmptyBufferTestStep testStep(sink, testBuffer, dummySource, dataPtr, copyOfDataPtr);

  6882 	DoTest(testStep, _L("Descriptor sink EmptyBufferL"), KErrNotSupported);

  6883 	CleanupStack::PopAndDestroy(testBuffer);

  6885 	// Test valid empty.

  6886 	TEmptyBufferTestStep testStep2(sink, validBuffer, dummySource, dataPtr, copyOfDataPtr);

  6887 	DoTestStep(testStep2, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6889 	dataPtr.SetLength(0);

  6890 	copyOfDataPtr.SetLength(0);

  6891 	testStep2.SetPosition(0);

  6892 	DoTestStepWithAllocFail(testStep2, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6894 	// Test complete empty.

  6895 	TEmptyBufferTestStep testStep3(sink, validBuffer, dummySource, dataPtr, copyOfDataPtr);

  6897 	dataPtr.SetLength(0);

  6898 	copyOfDataPtr.SetLength(0);

  6899 	const TUint8* sinkPtr = baseDataPtr;

  6900 	TInt bufferSize;

  6901 	do

  6902 		{

  6903 		bufferSize = Min(KTestWriteSize, KTestDataSize - (sinkPtr-baseDataPtr));

  6904 		validBuffer->Data().SetLength(bufferSize);

  6906 		testStep3.SetWriteLength(bufferSize);

  6907 		DoTestStep(testStep3, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6909 		sinkPtr += bufferSize;

  6910 		} while (bufferSize == KTestWriteSize);

  6912 	// Test complete empty with alloc fail.

  6913 	TEmptyBufferTestStep testStep4(sink, validBuffer, dummySource, dataPtr, copyOfDataPtr);

  6914 	validBuffer->Data().SetLength(KTestWriteSize);

  6916 	dataPtr.SetLength(0);

  6917 	copyOfDataPtr.SetLength(0);

  6918 	sinkPtr = baseDataPtr;

  6919 	do

  6920 		{

  6921 		bufferSize = Min(KTestWriteSize, KTestDataSize - (sinkPtr-baseDataPtr));

  6922 		validBuffer->Data().SetLength(bufferSize);

  6924 		testStep4.SetWriteLength(bufferSize);

  6925 		DoTestStepWithAllocFail(testStep4, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6927 		bufferSize = validBuffer->BufferSize();

  6928 		sinkPtr += bufferSize;

  6929 		} while (bufferSize == KTestWriteSize);

  6931 	// Test additional empty request.

  6932 	TEmptyBufferTestStep testStep5(sink, validBuffer, dummySource, dataPtr, copyOfDataPtr);

  6934 	testStep5.SetWriteLength(0);

  6935 	DoTest(testStep5, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6937 	// Test zero length write.

  6938 	dataPtr.SetLength(0);

  6939 	copyOfDataPtr.SetLength(0);

  6940 	TEmptyBufferTestStep testStep6(sink, zeroBuffer, dummySource, dataPtr, copyOfDataPtr);

  6941 	DoTest(testStep6, _L("Descriptor sink EmptyBufferL"), KErrNone);

  6943 	// Test over size write.

  6944 	TEmptyBufferTestStep testStep7(sink, bigBuffer, dummySource, dataPtr, copyOfDataPtr);

  6945 	testStep7.SetWriteLength(KTestDataSize);

  6946 	DoTestStep(testStep7, _L("Descriptor sink EmptyBufferL"), KErrNone /* Should probably be KErrOverflow */);

  6948 	dataPtr.SetLength(0);

  6949 	copyOfDataPtr.SetLength(0);

  6950 	testStep7.SetPosition(0);

  6951 	DoTestStepWithAllocFail(testStep7, _L("Descriptor sink EmptyBufferL"), KErrNone /* Should probably be KErrOverflow */);

  6953 	CleanupStack::PopAndDestroy(5, zeroBuffer); // sink, dummySource, validBuffer, bigBuffer, zeroBuffer

  6955 	CleanupStack::PopAndDestroy(2, dataDes); // copyOfDataDes, dataDes

  6957 	__MM_HEAP_MARKEND;

  6958 	return iTestResult;

  6959 	}

  6961 /**

  6962  *

  6963  * CTestStep_MMF_SRSSNK_U_0012 constructor

  6964  *

  6965  * @xxxx

  6966  *

  6967  */

  6968 CTestStep_MMF_SRSSNK_U_0012::CTestStep_MMF_SRSSNK_U_0012()

  6969 : CTestStep_MMF_SRSSNK(EFalse)

  6970 	{

  6971 	// store the name of this test case

  6972 	// this is the name that is used by the script file

  6973 	// Each test step initialises it's own name

  6974 	iTestStepName = _L("MM-MMF-SRSSNK-U-0012");

  6975 	}

  6977 /**

  6978  *

  6979  * CTestStep_MMF_SRSSNK_U_0012 destructor

  6980  *

  6981  * @xxxx

  6982  *

  6983  */

  6984 CTestStep_MMF_SRSSNK_U_0012::~CTestStep_MMF_SRSSNK_U_0012()

  6985 	{

  6986 	}

  6988 /**

  6989  *

  6990  * CTestStep_MMF_SRSSNK_U_0012

  6991  *

  6992  * Functional test of descriptor sink.

  6993  * BufferFilledL() panic test.

  6994  *

  6995  * @xxxx

  6996  */

  6997 TVerdict CTestStep_MMF_SRSSNK_U_0012::DoTestStepL()

  6998 	{

  6999 	__MM_HEAP_MARK;

  7001 	// This test fails if running a debug StdSourcesAndSinks dll.

  7002 	// So only perform the test on target.

  7004 	// Create sink buffer.

  7005 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  7006 	TPtr8 dataPtr(dataDes->Des());

  7008 	// Initialise config data.

  7009 	TMMFDescriptorConfig configDes;

  7010 	configDes().iDes = &dataPtr;

  7011 	configDes().iDesThreadId = RThread().Id();

  7013 	// Create valid buffer.

  7014 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  7015 	CleanupStack::PushL(validBuffer);

  7017 	// Create descriptor sink.

  7018 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfDescriptorSink, configDes);

  7019 	CleanupDeletePushL(sink);

  7021 	// Test BufferFilledL

  7022 	sink->BufferFilledL(validBuffer);

  7024 	CleanupStack::PopAndDestroy(sink);

  7026 	CleanupStack::PopAndDestroy(2, dataDes); // validBuffer, dataDes

  7028 	__MM_HEAP_MARKEND;

  7029 	return iTestResult;

  7030 	}

  7032 /**

  7033  *

  7034  * CTestStep_MMF_SRSSNK_U_0013 constructor

  7035  *

  7036  * @xxxx

  7037  *

  7038  */

  7039 CTestStep_MMF_SRSSNK_U_0013::CTestStep_MMF_SRSSNK_U_0013()

  7040 	{

  7041 	// store the name of this test case

  7042 	// this is the name that is used by the script file

  7043 	// Each test step initialises it's own name

  7044 	iTestStepName = _L("MM-MMF-SRSSNK-U-0013");

  7045 	}

  7047 /**

  7048  *

  7049  * CTestStep_MMF_SRSSNK_U_0013 destructor

  7050  *

  7051  * @xxxx

  7052  *

  7053  */

  7054 CTestStep_MMF_SRSSNK_U_0013::~CTestStep_MMF_SRSSNK_U_0013()

  7055 	{

  7056 	}

  7058 /**

  7059  *

  7060  * CTestStep_MMF_SRSSNK_U_0013

  7061  *

  7062  * Functional test of descriptor sink.

  7063  * WriteBufferL() test.

  7064  *

  7065  * @xxxx

  7066  */

  7067 TVerdict CTestStep_MMF_SRSSNK_U_0013::DoTestStepL()

  7068 	{

  7069 	__MM_HEAP_MARK;

  7071 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  7072 	TPtr8 dataPtr(dataDes->Des());

  7073 	TUint8* baseDataPtr = CONST_CAST(TUint8*, dataPtr.Ptr());

  7075 	HBufC8* copyOfDataDes = HBufC8::NewLC(KTestDataSize);

  7076 	TPtr8 copyOfDataPtr(copyOfDataDes->Des());

  7078 	// Randomise the data.

  7079 	TTime seedTime;

  7080 	seedTime.UniversalTime();

  7081 	TInt64 seed = seedTime.Int64();

  7082 	for (TInt i = 0 ; i<KTestDataSize ; i++)

  7083 		baseDataPtr[i] = TUint8(Math::Rand(seed));

  7084 	Mem::Copy(CONST_CAST(TUint8*, copyOfDataPtr.Ptr()), baseDataPtr, KTestDataSize);

  7086 	// Initialise config data.

  7087 	TMMFDescriptorConfig configDes;

  7088 	configDes().iDes = &dataPtr;

  7089 	configDes().iDesThreadId = RThread().Id();

  7091 	// Create valid Buffer.

  7092 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  7093 	CleanupStack::PushL(validBuffer);

  7095 	// Set the length to write.

  7096 	validBuffer->Data().SetLength(KTestWriteSize);

  7098 	// Create dummy source.

  7099 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  7100 	CleanupStack::PushL(dummySource);

  7102 	// Create sink descriptor.

  7103 	CMMFClip* sink = STATIC_CAST(CMMFClip*, MDataSink::NewSinkL(KUidMmfDescriptorSink, configDes));

  7104 	CleanupStack::PushL(sink);

  7106 	// Create test (invalid) buffer.

  7107 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  7108 	CleanupStack::PushL(testBuffer);

  7110 	// Test WriteBufferL (these tests should fail)

  7111 	TDescriptorClipWriteBufferTestStep testStep(sink, testBuffer, 0, dummySource, dataPtr, copyOfDataPtr);

  7112 	DoTest(testStep, _L("Descriptor sink WriteBufferL"), KErrNotSupported);

  7114 	TDescriptorClipWriteBuffer2TestStep testStep2(sink, testBuffer, 0, dummySource, dataPtr, copyOfDataPtr, KTestBufferSize);

  7115 	DoTest(testStep2, _L("Descriptor sink WriteBufferL"), KErrNotSupported);

  7117 	TDescriptorClipWriteBuffer3TestStep testStep3(sink, testBuffer, 0, dataPtr, copyOfDataPtr, KTestBufferSize);

  7118 	DoTest(testStep3, _L("Descriptor sink WriteBufferL"), KErrNotSupported);

  7119 	CleanupStack::PopAndDestroy(testBuffer);

  7121 	// Test writing to the beginning, middle, and end ofthe descriptor.

  7122 	TDescriptorClipWriteBufferTestStep testStep4(sink, validBuffer, 0, dummySource, dataPtr, copyOfDataPtr, KTestWriteSize);

  7123 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7125 	testStep4.SetPosition(1);

  7126 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7128 	testStep4.SetPosition(KTestDataSize/2);

  7129 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7131 	testStep4.SetPosition(KTestDataSize/2 + 1);

  7132 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7134 	testStep4.SetPosition(KTestDataSize-10);

  7135 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7137 	testStep4.SetWriteLength(11);

  7138 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7140 	testStep4.SetWriteLength(10);

  7141 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7143 	testStep4.SetPosition(KTestDataSize);

  7144 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7146 	testStep4.SetWriteLength(0);

  7147 	DoTest(testStep4, _L("Descriptor sink WriteBufferL"), KErrNone);

  7149 	testStep4.SetPosition(KTestDataSize + 2);

  7150 	DoTest(testStep4, _L("Descriptor source WriteBufferL"), KErrArgument);

  7152 	// Attempt to write nothing.

  7153 	TDescriptorClipWriteBufferTestStep testStep5(sink, validBuffer, 0, dummySource, dataPtr, copyOfDataPtr);

  7154 	DoTest(testStep5, _L("Descriptor sink WriteBufferL"), KErrNone);

  7156 	// Attempt to write more data than is actually in the buffer.

  7157 	testStep5.SetWriteLength(KTestOverWriteSize);

  7158 	DoTest(testStep5, _L("Descriptor sink WriteBufferL"), KErrArgument);

  7160 	// Repeat writes with full length descriptor.

  7161 	dataPtr.SetLength(KTestDataSize);

  7162 	copyOfDataPtr.SetLength(KTestDataSize);

  7164 	TDescriptorClipWriteBufferTestStep testStep6(sink, validBuffer, 0, dummySource, dataPtr, copyOfDataPtr, KTestWriteSize);

  7165 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7167 	testStep6.SetPosition(1);

  7168 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7170 	testStep6.SetPosition(KTestDataSize/2);

  7171 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7173 	testStep6.SetPosition(KTestDataSize/2 + 1);

  7174 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7176 	testStep6.SetPosition(KTestDataSize - 10);

  7177 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7179 	testStep6.SetWriteLength(11);

  7180 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7182 	testStep6.SetWriteLength(10);

  7183 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7185 	testStep6.SetPosition(KTestDataSize);

  7186 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7188 	testStep6.SetWriteLength(0);

  7189 	DoTest(testStep6, _L("Descriptor sink WriteBufferL"), KErrNone);

  7191 	testStep6.SetPosition(KTestDataSize + 2);

  7192 	DoTest(testStep6, _L("Descriptor source WriteBufferL"), KErrArgument);

  7194 	// Reset descriptor.

  7195 	dataPtr.SetLength(0);

  7196 	copyOfDataPtr.SetLength(0);

  7198 	// Repeat writes without supplying the length to write.

  7199 	TDescriptorClipWriteBuffer2TestStep testStep7(sink, validBuffer, 0, dummySource, dataPtr, copyOfDataPtr, KTestWriteSize);

  7200 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7202 	testStep7.SetPosition(1);

  7203 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7205 	testStep7.SetPosition(KTestDataSize/2);

  7206 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7208 	testStep7.SetPosition(KTestDataSize/2 + 1);

  7209 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7211 	testStep7.SetPosition(KTestDataSize - 10);

  7212 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7214 	validBuffer->Data().SetLength(11);

  7215 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7217 	validBuffer->Data().SetLength(10);

  7218 	testStep7.SetWriteLength(10);

  7219 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7221 	testStep7.SetPosition(KTestDataSize);

  7222 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7224 	validBuffer->Data().SetLength(0);

  7225 	testStep7.SetWriteLength(0);

  7226 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7228 	testStep7.SetPosition(KTestDataSize + 2);

  7229 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrArgument);

  7231 	// Attempt to write nothing.

  7232 	testStep7.SetPosition(0);

  7233 	DoTest(testStep7, _L("Descriptor sink WriteBufferL"), KErrNone);

  7235 	// Repeat writes with full length descriptor.

  7236 	dataPtr.SetLength(KTestDataSize);

  7237 	copyOfDataPtr.SetLength(KTestDataSize);

  7238 	validBuffer->Data().SetLength(KTestWriteSize);

  7240 	TDescriptorClipWriteBuffer2TestStep testStep8(sink, validBuffer, 0, dummySource, dataPtr, copyOfDataPtr, KTestWriteSize);

  7241 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7243 	testStep8.SetPosition(1);

  7244 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7246 	testStep8.SetPosition(KTestDataSize/2);

  7247 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7249 	testStep8.SetPosition(KTestDataSize/2 + 1);

  7250 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7252 	testStep8.SetPosition(KTestDataSize - 10);

  7253 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7255 	validBuffer->Data().SetLength(11);

  7256 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7258 	validBuffer->Data().SetLength(10);

  7259 	testStep8.SetWriteLength(10);

  7260 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7262 	testStep8.SetPosition(KTestDataSize);

  7263 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7265 	validBuffer->Data().SetLength(0);

  7266 	testStep8.SetWriteLength(0);

  7267 	DoTest(testStep8, _L("Descriptor sink WriteBufferL"), KErrNone);

  7269 	testStep8.SetPosition(KTestDataSize + 2);

  7270 	DoTest(testStep8, _L("Descriptor source WriteBufferL"), KErrArgument);

  7272 	// Reset descriptor.

  7273 	dataPtr.SetLength(0);

  7274 	copyOfDataPtr.SetLength(0);

  7275 	validBuffer->Data().SetLength(KTestWriteSize);

  7277 	// Repeat writes without supplying the length, or a sink.

  7278 	TDescriptorClipWriteBuffer3TestStep testStep9(sink, validBuffer, 0, dataPtr, copyOfDataPtr, KTestWriteSize);

  7279 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7281 	testStep9.SetPosition(1);

  7282 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7284 	testStep9.SetPosition(KTestDataSize/2);

  7285 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7287 	testStep9.SetPosition(KTestDataSize/2 + 1);

  7288 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7290 	testStep9.SetPosition(KTestDataSize - 10);

  7291 	DoTest(testStep9, _L("Descriptor source ReadBufferL"), KErrOverflow);

  7293 	validBuffer->Data().SetLength(11);

  7294 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7296 	validBuffer->Data().SetLength(10);

  7297 	testStep9.SetWriteLength(10);

  7298 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7300 	validBuffer->Data().SetLength(0);

  7301 	testStep9.SetPosition(KTestDataSize);

  7302 	testStep9.SetWriteLength(0);

  7303 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7305 	testStep9.SetPosition(KTestDataSize + 2);

  7306 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrArgument);

  7308 	// Attempt to write nothing.

  7309 	testStep9.SetPosition(0);

  7310 	DoTest(testStep9, _L("Descriptor sink WriteBufferL"), KErrNone);

  7312 	// Repeat writes with full length descriptor.

  7313 	dataPtr.SetLength(KTestDataSize);

  7314 	copyOfDataPtr.SetLength(KTestDataSize);

  7315 	validBuffer->Data().SetLength(KTestWriteSize);

  7317 	TDescriptorClipWriteBuffer3TestStep testStep10(sink, validBuffer, 0, dataPtr, copyOfDataPtr, KTestWriteSize);

  7318 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7320 	testStep10.SetPosition(1);

  7321 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7323 	testStep10.SetPosition(KTestDataSize/2);

  7324 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7326 	testStep10.SetPosition(KTestDataSize/2 + 1);

  7327 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7329 	testStep10.SetPosition(KTestDataSize - 10);

  7330 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7332 	validBuffer->Data().SetLength(11);

  7333 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7335 	validBuffer->Data().SetLength(10);

  7336 	testStep10.SetWriteLength(10);

  7337 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7339 	testStep10.SetPosition(KTestDataSize);

  7340 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrOverflow);

  7342 	validBuffer->Data().SetLength(0);

  7343 	testStep10.SetWriteLength(0);

  7344 	DoTest(testStep10, _L("Descriptor sink WriteBufferL"), KErrNone);

  7346 	testStep10.SetPosition(KTestDataSize + 2);

  7347 	DoTest(testStep10, _L("Descriptor source WriteBufferL"), KErrArgument);

  7349 	CleanupStack::PopAndDestroy(3, validBuffer); // sink, dummySource, validBuffer

  7351 	CleanupStack::PopAndDestroy(2, dataDes); // copyOfDataDes, dataDes

  7353 	__MM_HEAP_MARKEND;

  7354 	return iTestResult;

  7355 	}

  7358 /**

  7359  *

  7360  * CTestStep_MMF_SRSSNK_U_0014 constructor

  7361  *

  7362  * @xxxx

  7363  *

  7364  */

  7365 CTestStep_MMF_SRSSNK_U_0014::CTestStep_MMF_SRSSNK_U_0014()

  7366 	{

  7367 	// store the name of this test case

  7368 	// this is the name that is used by the script file

  7369 	// Each test step initialises it's own name

  7370 	iTestStepName = _L("MM-MMF-SRSSNK-U-0014");

  7371 	}

  7373 /**

  7374  *

  7375  * CTestStep_MMF_SRSSNK_U_0014 destructor

  7376  *

  7377  * @xxxx

  7378  *

  7379  */

  7380 CTestStep_MMF_SRSSNK_U_0014::~CTestStep_MMF_SRSSNK_U_0014()

  7381 	{

  7382 	}

  7384 /**

  7385  *

  7386  * CTestStep_MMF_SRSSNK_U_0014

  7387  *

  7388  * Functional test of descriptor sink.

  7389  * SinkCustomCommand() test.

  7390  *

  7391  * @xxxx

  7392  */

  7393 TVerdict CTestStep_MMF_SRSSNK_U_0014::DoTestStepL()

  7394 	{

  7395 	__MM_HEAP_MARK;

  7397 	// Create sink buffer.

  7398 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  7399 	TPtr8 dataPtr(dataDes->Des());

  7401 	// Initialise config data.

  7402 	TMMFDescriptorConfig configDes;

  7403 	configDes().iDes = &dataPtr;

  7404 	configDes().iDesThreadId = RThread().Id();

  7406 	TUid testControllerUid = { KMmfTestControllerUid };

  7407 	RMMFController dummyController;

  7408 	TMMFPrioritySettings prioritySettings;

  7409 	TMMFMessageDestinationPckg destination;

  7410 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

  7411 	CleanupClosePushL(dummyController);

  7413 	TBuf8<1> dummyArgs;

  7414 	User::LeaveIfError(dummyController.AddDataSink(KUidMmfDescriptorSink, configDes));

  7415 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSink, dummyArgs, dummyArgs);

  7416 	if (err != KErrNotSupported)

  7417 		{

  7418 		INFO_PRINTF2(_L("Descriptor sink SinkCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

  7419 		iTestResult = EFail;

  7420 		}

  7422 	CleanupStack::PopAndDestroy(2, dataDes); // dummyController, dataDes.

  7424 	__MM_HEAP_MARKEND;

  7425 	return iTestResult;

  7426 	}

  7428 /**

  7429  *

  7430  * CTestStep_MMF_SRSSNK_U_0015 constructor

  7431  *

  7432  * @xxxx

  7433  *

  7434  */

  7435 CTestStep_MMF_SRSSNK_U_0015::CTestStep_MMF_SRSSNK_U_0015()

  7436 	{

  7437 	// store the name of this test case

  7438 	// this is the name that is used by the script file

  7439 	// Each test step initialises it's own name

  7440 	iTestStepName = _L("MM-MMF-SRSSNK-U-0015");

  7441 	}

  7443 /**

  7444  *

  7445  * CTestStep_MMF_SRSSNK_U_0015 destructor

  7446  *

  7447  * @xxxx

  7448  *

  7449  */

  7450 CTestStep_MMF_SRSSNK_U_0015::~CTestStep_MMF_SRSSNK_U_0015()

  7451 	{

  7452 	}

  7454 /**

  7455  *

  7456  * CTestStep_MMF_SRSSNK_U_0015

  7457  *

  7458  * CMMFDescriptor

  7459  * Request size / SetLastBuffer test.

  7460  *

  7461  * @xxxx

  7462  */

  7463 TVerdict CTestStep_MMF_SRSSNK_U_0015::DoTestStepL()

  7464 	{

  7465 	__MM_HEAP_MARK;

  7467 	// Create source buffer.

  7468 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  7469 	TPtr8 dataPtr(dataDes->Des());

  7471 	// Set it's length.

  7472 	dataPtr.SetLength(KTestDataSize);

  7474 	TTime seedTime;

  7475 	seedTime.UniversalTime();

  7476 	TInt64 seed = seedTime.Int64();

  7477 	for (TInt i = 0 ; i<KTestDataSize ; i++)

  7478 		dataPtr[i] = TUint8(Math::Rand(seed));

  7480 	// Initialise config data.

  7481 	TMMFDescriptorConfig configDes;

  7482 	configDes().iDes = &dataPtr;

  7483 	configDes().iDesThreadId = RThread().Id();

  7485 	// Create dummy sink.

  7486 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  7487 	CleanupStack::PushL(dummySink);

  7489 	// Test fill last buffer

  7490 	TFillLastBufferTestStep testStep(KUidMmfDescriptorSource, configDes, dummySink, dataPtr);

  7491 	DoTest(testStep, _L("Descriptor source: Fill last buffer"), KErrNone);

  7493 	// Create a source.

  7494 	CMMFClip* source = STATIC_CAST(CMMFClip*, MDataSource::NewSourceL(KUidMmfDescriptorSource, configDes));

  7495 	CleanupStack::PushL(source);

  7497 	// Test read last buffer (API version 1)

  7498 	TReadLastBufferTestStep testStep2(source, dummySink, dataPtr);

  7499 	DoTest(testStep2, _L("Descriptor source: Read last buffer"), KErrNone);

  7501 	TReadLastBuffer2TestStep testStep3(source, dummySink, dataPtr);

  7502 	DoTest(testStep3, _L("Descriptor source: Read last buffer"), KErrNone);

  7504 	TReadLastBuffer3TestStep testStep4(source, dataPtr);

  7505 	DoTest(testStep4, _L("Descriptor source: Read last buffer"), KErrNone);

  7507 	CleanupStack::PopAndDestroy(source);

  7509 	CleanupStack::PopAndDestroy(2, dataDes); // dummySink, dataDes

  7511 	__MM_HEAP_MARKEND;

  7512 	return iTestResult;

  7513 	}

  7516 /**

  7517  *

  7518  * CTestStep_MMF_SRSSNK_U_0101 constructor

  7519  *

  7520  * @xxxx

  7521  *

  7522  */

  7523 CTestStep_MMF_SRSSNK_U_0101::CTestStep_MMF_SRSSNK_U_0101()

  7524 	{

  7525 	// store the name of this test case

  7526 	// this is the name that is used by the script file

  7527 	// Each test step initialises it's own name

  7528 	iTestStepName = _L("MM-MMF-SRSSNK-U-0101");

  7529 	}

  7531 /**

  7532  *

  7533  * CTestStep_MMF_SRSSNK_U_0101 destructor

  7534  *

  7535  * @xxxx

  7536  *

  7537  */

  7538 CTestStep_MMF_SRSSNK_U_0101::~CTestStep_MMF_SRSSNK_U_0101()

  7539 	{

  7540 	}

  7542 /**

  7543  *

  7544  * CTestStep_MMF_SRSSNK_U_0101

  7545  *

  7546  * Test creation/destruction of file source.

  7547  *

  7548  * @xxxx

  7549  */

  7550 _LIT(KTest101CopyFileName, "c:\\mm\\mmf\\testfiles\\srssnk\\CopyOfMMFTestFile1.dat");

  7551 TVerdict CTestStep_MMF_SRSSNK_U_0101::DoTestStepL()

  7552 	{

  7553 	__MM_HEAP_MARK;

  7555 	// Get file info.

  7556 	RFs testFsSession;

  7557 	User::LeaveIfError(testFsSession.Connect()) ;

  7558 	CleanupClosePushL(testFsSession);

  7560 	// Get the size of the test file.

  7561 	RFile testFile;

  7562 	TFileName testFileName(KTest101FileName);

  7563 	User::LeaveIfError(testFile.Open(testFsSession, testFileName, EFileRead));

  7564 	CleanupClosePushL(testFile);

  7566 	// Force delete of the copied file - test will leave otherwise

  7567 	TInt err = testFsSession.Delete(KTest101CopyFileName);

  7568 	if (err == KErrAccessDenied)

  7569 		{

  7570 		// It's read-only, remove the read-only attribute

  7571 		err = testFsSession.SetAtt(KTest101CopyFileName, 0, KEntryAttReadOnly);

  7572 		if (err == KErrNone)

  7573 			{

  7574 			// Try deleting again

  7575 			err = testFsSession.Delete(KTest101CopyFileName);

  7576 			}

  7577 		User::LeaveIfError(err);

  7578 		}

  7580 	TInt fileSize;

  7581 	User::LeaveIfError(testFile.Size(fileSize));

  7582 	CleanupStack::PopAndDestroy(); // testFile

  7584 	// Copy the file. (Remaining tests work with the copy)

  7585 	CopyFileL(testFsSession, testFileName, KTest101CopyFileName);

  7587 	// Get the free space on the drive.

  7588 	testFileName = KTest101CopyFileName;

  7589 	TParsePtr parser(testFileName);

  7590 	TDriveUnit drive(parser.Drive());

  7591 	TVolumeInfo volInfo;

  7592 	User::LeaveIfError(testFsSession.Volume(volInfo, drive));

  7594 	TInt64 freeSpace = volInfo.iFree;

  7597 	// Set the read only attribute

  7598 	err = testFsSession.SetAtt(testFileName, KEntryAttReadOnly, 0);

  7599 	if (err != KErrNone)

  7600 		{

  7601 		INFO_PRINTF2(_L("Error setting read-only attribute (%d)"), err);

  7602 		iTestResult = EFail;

  7603 		}

  7605 	// Initialise config data.

  7606 	TMMFFileConfig configDes;

  7607 	configDes().iPath = testFileName;

  7609 	// Test valid uid and configuration descriptor.

  7610 	TNewSourceTestStep testStep(KUidMmfFileSource, configDes);

  7611 	DoFileTest(testStep, _L("Construct file source"), KErrNone);

  7613 	// Test that the source has been initialised correctly.

  7614 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

  7615 	CleanupDeletePushL(source);

  7617 	// Test that the file has been opened correctly.

  7618 	source->SourcePrimeL();

  7619 	RFile& file = (STATIC_CAST(CMMFFile*, source))->FileL();

  7621 	// Read some bytes from the file. (Check it is as we would expect)

  7622 	TBuf8<256> sourceBytes;

  7623 	file.Read(sourceBytes);

  7624 	for (TInt i = 0 ; i<256 ; i++)

  7625 		{

  7626 		if (sourceBytes[i] != i)

  7627 			{

  7628 			INFO_PRINTF3(_L("Construct file source: %d, actually got %d"), sourceBytes[i], i);

  7629 			iTestResult = EFail;

  7630 			}

  7631 		}

  7633 	// Test that the source is initialised correctly.

  7634 	TSourceTypeTestStep testStep2(source, KUidMmfFileSource, KMMFFourCCCodeNULL, EFalse);

  7635 	DoTest(testStep2, _L("File source type"), KErrNone);

  7637 	TCanCreateSourceBufferTestStep testStep3(source, EFalse);

  7638 	DoTest(testStep3, _L("File CanCreateSourceBuffer"), KErrNone);

  7640 	TSourceSampleConvertTestStep testStep4(source, EFalse);

  7641 	DoTest(testStep4, _L("File source SourceSampleConvert"), KErrNone);

  7643 	// Test that the clip is initialised correctly.

  7644 	CMMFClip *sourceClip = STATIC_CAST(CMMFClip*, source);

  7646 	// do a bytes free test

  7647 	TClipBytesFreeTestStep testStep5(sourceClip, freeSpace);

  7648 	DoFileTest(testStep5, _L("File source BytesFree"), KErrNone);

  7650 	TClipSizeTestStep testStep6(sourceClip, fileSize);

  7651 	DoFileTest(testStep6, _L("File source Size"), KErrNone);

  7653 	TClipSetSizeTestStep testStep7(sourceClip, ETrue);

  7654 	DoFileTest(testStep7, _L("File source SetSize"), KErrAccessDenied);

  7656 	TClipDeleteTestStep testStep8(sourceClip);

  7657 	DoFileTest(testStep8, _L("File source Delete"), KErrAccessDenied);

  7659 	CleanupStack::PopAndDestroy(source);

  7661 	// Remove the read only attribute.

  7662 	err = testFsSession.SetAtt(testFileName, 0, KEntryAttReadOnly);

  7663 	if (err != KErrNone)

  7664 		{

  7665 		INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  7666 		iTestResult = EFail;

  7667 		}

  7669 	sourceClip = STATIC_CAST(CMMFClip*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

  7670 	CleanupStack::PushL(sourceClip);

  7672 	sourceClip->SourcePrimeL();

  7673 	TClipSetSizeTestStep testStep9(sourceClip, EFalse);

  7674 	DoFileTest(testStep9, _L("File source SetSize"), KErrAccessDenied);

  7676 	CleanupStack::PopAndDestroy(sourceClip);

  7678 /* Note - cannot set the size of a source

  7679 	// Check the size.

  7680 	User::LeaveIfError(testFile.Open(testFsSession, testFileName, EFileRead));

  7682 	TInt size;

  7683 	err = testFile.Size(size);

  7684 	if (err != KErrNone)

  7685 		{

  7686 		INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  7687 		iTestResult = EFail;

  7688 		}

  7689 	testFile.Close();

  7691 	if (size != fileSize+6) // fileSize+6 is the result from SetSize test.

  7692 		{

  7693 		INFO_PRINTF3(_L("File source Size: Expecting %d, actually got %d"), fileSize+6, size);

  7694 		iTestResult = EFail;

  7695 		}

  7696 */

  7698 	CMMFFile* sourceFile = STATIC_CAST(CMMFFile*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

  7699 	CleanupStack::PushL(sourceFile);

  7701 	const TDesC& fileName = sourceFile->FileName();

  7702 	if (fileName.Compare(parser.Name()))

  7703 		{

  7704 		INFO_PRINTF3(_L("File source FileName: Expecting %S, actually got %S"), parser.Name().Ptr(), fileName.Ptr());

  7705 		iTestResult = EFail;

  7706 		}

  7708 	const TDesC& extName = sourceFile->Extension();

  7709 	if (extName.Compare(parser.Ext()))

  7710 		{

  7711 		INFO_PRINTF3(_L("File source FileName: Expecting %S, actually got %S"), parser.Ext().Ptr(), extName.Ptr());

  7712 		iTestResult = EFail;

  7713 		}

  7715 	DoTestStep(testStep8, _L("File source Delete"), KErrNone);

  7717 	// Check that the file has actually been deleted.

  7718 	err = testFile.Open(testFsSession, testFileName, EFileRead);

  7719 	if (err != KErrNotFound)

  7720 		{

  7721 		testFile.Close();

  7723 		INFO_PRINTF2(_L("File source Delete: Expecting KErrNotFound, actually got %d"), err);

  7724 		iTestResult = EFail;

  7725 		}

  7727 	// Copy the file (again).

  7728 	CopyFileL(testFsSession, KTest101FileName, KTest101CopyFileName);

  7730 	// Remove the read only attribute.

  7731 	err = testFsSession.SetAtt(testFileName, 0, KEntryAttReadOnly);

  7732 	if (err != KErrNone)

  7733 		{

  7734 		INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  7735 		iTestResult = EFail;

  7736 		}

  7738 	CleanupStack::PopAndDestroy(sourceFile);

  7740 	sourceFile = STATIC_CAST(CMMFFile*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

  7741 	CleanupStack::PushL(sourceFile);

  7743 	TClipDeleteTestStep testStep10(sourceFile);

  7744 	DoTestStepWithAllocFail(testStep10, _L("File source Delete"), KErrNone);

  7746 	// Check that the file has actually been deleted.

  7747 	err = testFile.Open(testFsSession, testFileName, EFileRead);

  7748 	if (err != KErrNotFound)

  7749 		{

  7750 		testFile.Close();

  7752 		INFO_PRINTF2(_L("File source Delete: Expecting KErrNotFound, actually got %d"), err);

  7753 		iTestResult = EFail;

  7754 		}

  7756 	// Copy the file (again).

  7757 	CopyFileL(testFsSession, KTest101FileName, KTest101CopyFileName);

  7759 	// Remove the read only attribute.

  7760 	err = testFsSession.SetAtt(testFileName, 0, KEntryAttReadOnly);

  7761 	if (err != KErrNone)

  7762 		{

  7763 		INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  7764 		iTestResult = EFail;

  7765 		}

  7767 	CleanupStack::PopAndDestroy(sourceFile);

  7769 	if (iFileFailureTestingEnabled)

  7770 		{

  7771 		sourceFile = STATIC_CAST(CMMFFile*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

  7772 		CleanupStack::PushL(sourceFile);

  7774 		TClipDeleteTestStep testStep11(sourceFile);

  7775 		DoTestStepWithFileFail(testStep11, _L("File source Delete"), KErrNone);

  7777 		// Check that the file has actually been deleted.

  7778 		err = testFile.Open(testFsSession, testFileName, EFileRead);

  7779 		if (err != KErrNotFound)

  7780 			{

  7781 			testFile.Close();

  7783 			INFO_PRINTF2(_L("File source Delete: Expecting KErrNotFound, actually got %d"), err);

  7784 			iTestResult = EFail;

  7785 			}

  7787 		// Copy the file (again).

  7788 		CopyFileL(testFsSession, KTest101FileName, KTest101CopyFileName);

  7790 		// Remove the read only attribute.

  7791 		err = testFsSession.SetAtt(testFileName, 0, KEntryAttReadOnly);

  7792 		if (err != KErrNone)

  7793 			{

  7794 			INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  7795 			iTestResult = EFail;

  7796 			}

  7798 		CleanupStack::PopAndDestroy(sourceFile);

  7800 /*

  7801 		// DoTestStepWithAllocAndFileFail test is no longer run.

  7802 		// Code kept for reference purposes.

  7803 		sourceFile = STATIC_CAST(CMMFFile*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

  7804 		CleanupStack::PushL(sourceFile);

  7806 		TClipDeleteTestStep testStep12(sourceFile);

  7807 		DoTestStepWithAllocAndFileFail(testStep12, _L("File source Delete"), KErrNone);

  7809 		// Check that the file has actually been deleted.

  7810 		err = testFile.Open(testFsSession, testFileName, EFileRead);

  7811 		if (err != KErrNotFound)

  7812 			{

  7813 			testFile.Close();

  7815 			INFO_PRINTF2(_L("File source Delete: Expecting KErrNotFound, actually got %d"), err);

  7816 			iTestResult = EFail;

  7817 			}

  7819 		CleanupStack::PopAndDestroy(sourceFile);

  7820 */

  7821 		}

  7823 	CleanupStack::PopAndDestroy(); // testFsSession

  7825 	__MM_HEAP_MARKEND;

  7826 	return iTestResult;

  7827 	}

  7829 /**

  7830  *

  7831  * CTestStep_MMF_SRSSNK_U_0102 constructor

  7832  *

  7833  * @xxxx

  7834  *

  7835  */

  7836 CTestStep_MMF_SRSSNK_U_0102::CTestStep_MMF_SRSSNK_U_0102()

  7837 	{

  7838 	// store the name of this test case

  7839 	// this is the name that is used by the script file

  7840 	// Each test step initialises it's own name

  7841 	iTestStepName = _L("MM-MMF-SRSSNK-U-0102");

  7842 	}

  7844 /**

  7845  *

  7846  * CTestStep_MMF_SRSSNK_U_0102 destructor

  7847  *

  7848  * @xxxx

  7849  *

  7850  */

  7851 CTestStep_MMF_SRSSNK_U_0102::~CTestStep_MMF_SRSSNK_U_0102()

  7852 	{

  7853 	}

  7855 /**

  7856  *

  7857  * CTestStep_MMF_SRSSNK_U_0102

  7858  *

  7859  * Attempt to create file source using invalid config data.

  7860  *

  7861  * @xxxx

  7862  */

  7863 _LIT(KTest102FileName1, "c:\\DefaultPathSource.dat"); // Valid but no path.

  7864 _LIT(KTest102FileName2, ""); // Definitely not valid.

  7865 TVerdict CTestStep_MMF_SRSSNK_U_0102::DoTestStepL()

  7866 	{

  7867 	__MM_HEAP_MARK;

  7869 	// Initialise config data.

  7870 	TMMFFileConfig configDes;

  7871 	configDes().iPath = KTest102FileName1;

  7873 	TNewSourceTestStep testStep(KUidMmfFileSource, configDes);

  7874 	DoFileTest(testStep, _L("Construct file source 102.1"), KErrNone);

  7876 	// Verify that the file has not been created.

  7877 	RFs testFsSession;

  7878 	User::LeaveIfError(testFsSession.Connect());

  7879 	CleanupClosePushL(testFsSession);

  7881 	RFile testFile;

  7882 	TInt err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  7883 	if (err != KErrNotFound)

  7884 		{

  7885 		testFile.Close();

  7886 		User::LeaveIfError(testFsSession.Delete(configDes().iPath));

  7888 		INFO_PRINTF2(_L("File source create: Expecting KErrNotFound, actually got %d"), err);

  7889 		iTestResult = EFail;

  7890 		}

  7892 	TNewFileSourceTestStep testStep2(KUidMmfFileSource, configDes);

  7893 	DoFileTest(testStep2, _L("Construct file source 102.2"), KErrNotFound);

  7895 	// Verify that the file has not been created.

  7896 	err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  7897 	if (err != KErrNotFound)

  7898 		{

  7899 		testFile.Close();

  7900 		User::LeaveIfError(testFsSession.Delete(configDes().iPath));

  7902 		INFO_PRINTF2(_L("File source create: Expecting KErrNotFound, actually got %d"), err);

  7903 		iTestResult = EFail;

  7904 		}

  7906 	if (iFileFailureTestingEnabled)

  7907 		{

  7908 		// Repeat test with file failure only. (Checks for file failure on creation)

  7909 		DoTestStepWithFileFail(testStep2, _L("Construct file source 102.3"), KErrNotFound);

  7911 		// Verify that the file has not been created.

  7912 		err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  7913 		if (err != KErrNotFound)

  7914 			{

  7915 			testFile.Close();

  7916 			User::LeaveIfError(testFsSession.Delete(configDes().iPath));

  7918 			INFO_PRINTF2(_L("File source create: Expecting KErrNotFound, actually got %d"), err);

  7919 			iTestResult = EFail;

  7920 			}

  7921 		}

  7923 	configDes().iPath = KTest102FileName2;

  7924 	TNewSourceTestStep testStep5(KUidMmfFileSource, configDes);

  7925 	DoFileTest(testStep5, _L("Construct file source 102.4"), KErrBadName);

  7927 	CleanupStack::PopAndDestroy(); // testFsSession

  7929 	__MM_HEAP_MARKEND;

  7931 	return iTestResult;

  7932 	}

  7934 /**

  7935  *

  7936  * CTestStep_MMF_SRSSNK_U_0103 constructor

  7937  *

  7938  * @xxxx

  7939  *

  7940  */

  7941 CTestStep_MMF_SRSSNK_U_0103::CTestStep_MMF_SRSSNK_U_0103()

  7942 	{

  7943 	// store the name of this test case

  7944 	// this is the name that is used by the script file

  7945 	// Each test step initialises it's own name

  7946 	iTestStepName = _L("MM-MMF-SRSSNK-U-0103");

  7947 	}

  7949 /**

  7950  *

  7951  * CTestStep_MMF_SRSSNK_U_0103 destructor

  7952  *

  7953  * @xxxx

  7954  *

  7955  */

  7956 CTestStep_MMF_SRSSNK_U_0103::~CTestStep_MMF_SRSSNK_U_0103()

  7957 	{

  7958 	}

  7960 /**

  7961  *

  7962  * CTestStep_MMF_SRSSNK_U_0103

  7963  *

  7964  * Test creation/destruction of file sink.

  7965  *

  7966  * @xxxx

  7967  */

  7968 _LIT(KTest103FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile4.dat");

  7969 TVerdict CTestStep_MMF_SRSSNK_U_0103::DoTestStepL()

  7970 	{

  7971 	__MM_HEAP_MARK;

  7972 	// Get file info.

  7973 	TInt64 freeSpace = 0;

  7975 	RFs testFsSession;

  7976 	User::LeaveIfError(testFsSession.Connect()) ;

  7977 	CleanupClosePushL(testFsSession);

  7979 	// Get the free space on the drive.

  7980 	TFileName testFileName(KTest103FileName);

  7981 	TParsePtr parser(testFileName);

  7982 	TDriveUnit drive(parser.Drive());

  7983 	TVolumeInfo volInfo;

  7984 	if (testFsSession.Volume(volInfo, drive) == KErrNone)

  7985 		freeSpace = volInfo.iFree;

  7987 	// Initialise config data.

  7988 	TMMFFileConfig configDes;

  7989 	configDes().iPath = testFileName;

  7991 	// Test valid uid and configuration descriptor.

  7992 	TNewSinkTestStep testStep(KUidMmfFileSink, configDes);

  7993 	DoFileTest(testStep, _L("Construst file sink 1"), KErrNone);

  7995 	// Test that the sink has been initialised correctly.

  7996 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfFileSink, configDes);

  7997 	CleanupDeletePushL(sink);

  7999 	// Test that the file has been opened correctly.

  8000 	sink->SinkPrimeL();

  8001 	RFile& file = (STATIC_CAST(CMMFFile*, sink))->FileL();

  8003 	// Attempt to read some bytes from the file. (Check it is as we would expect)

  8004 	TBuf8<256> sourceBytes;

  8005 	TInt err = file.Read(sourceBytes);

  8006 	if ((err != KErrNone) || (sourceBytes.Length() != 0))

  8007 		{

  8008 		INFO_PRINTF3(_L("Construct file sink: Expecting KErrNone + zero length file, actually got %d + %d bytes"), err, sourceBytes.Length());

  8009 		iTestResult = EFail;

  8010 		}

  8012 	// Test that the file is writable.

  8013 	TUint att;

  8014 	err = testFsSession.Att(testFileName, att);

  8015 	if ((err != KErrNone) || (att & KEntryAttReadOnly))

  8016 		{

  8017 		INFO_PRINTF3(_L("Create file sink : Expecting KErrNone + KEntryAttReadOnly, actually got %d, %x"), err, att);

  8018 		iTestResult = EFail;

  8019 		}

  8021 	// Test that the sink is initialised correctly.

  8022 	TSinkTypeTestStep testStep2(sink, KUidMmfFileSink, KMMFFourCCCodeNULL, EFalse);

  8023 	DoTest(testStep2, _L("Descriptor sink type 2"), KErrNone);

  8025  	TCanCreateSinkBufferTestStep testStep3(sink, EFalse);

  8026 	DoTest(testStep3, _L("Descriptor sink CanCreateSinkBuffer 3"), KErrNone);

  8028 	// Test that the clip is initialised correctly.

  8029 	CMMFClip *sinkClip = STATIC_CAST(CMMFClip*, sink);

  8031 	// do a bytes free test

  8032 	TClipBytesFreeTestStep testStep4(sinkClip, freeSpace);

  8033 	DoFileTest(testStep4, _L("Descriptor sink BytesFree 4"), KErrNone);

  8035 	TClipSizeTestStep testStep5(sinkClip, 0);

  8036 	DoFileTest(testStep5, _L("Descriptor sink Size 5"), KErrNone);

  8038 	TFileSinkSetSizeTestStep testStep6(sinkClip, ETrue);

  8039 	DoFileTest(testStep6, _L("Descriptor sink SetSize 6"), KErrNone);

  8041 	CleanupStack::PopAndDestroy(sink);

  8043 	// Set the read only attribute.

  8044 	err = testFsSession.SetAtt(testFileName, KEntryAttReadOnly, 0);

  8045 	if (err != KErrNone)

  8046 		{

  8047 		INFO_PRINTF2(_L("File source SetSize: Expecting KErrNone, actually got %d"), err);

  8048 		iTestResult = EFail;

  8049 		}

  8051 	sinkClip = STATIC_CAST(CMMFClip*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8052 	CleanupStack::PushL(sinkClip);

  8054 	sinkClip->SinkPrimeL();

  8055 	TFileSinkSetSizeTestStep testStep7(sinkClip, ETrue);

  8056 	DoFileTest(testStep7, _L("Descriptor sink SetSize 7"), KErrAccessDenied);

  8058 	TClipDeleteTestStep testStep8(sinkClip);

  8059 	DoFileTest(testStep8, _L("Descriptor sink Delete 8"), KErrAccessDenied);

  8061 	CleanupStack::PopAndDestroy(sinkClip);

  8063 	RFile testFile;

  8064 	// Check the filename.

  8065 	CMMFFile* sinkFile = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8066 	CleanupStack::PushL(sinkFile);

  8068 	const TDesC& fileName = sinkFile->FileName();

  8069 	if (fileName.Compare(parser.Name()))

  8070 		{

  8071 		INFO_PRINTF3(_L("File sink FileName: Expecting %S, actually got %S"), parser.Name().Ptr(), fileName.Ptr());

  8072 		iTestResult = EFail;

  8073 		}

  8075 	const TDesC& extName = sinkFile->Extension();

  8076 	if (extName.Compare(parser.Ext()))

  8077 		{

  8078 		INFO_PRINTF3(_L("File sink FileName: Expecting %S, actually got %S"), parser.Ext().Ptr(), extName.Ptr());

  8079 		iTestResult = EFail;

  8080 		}

  8082 	CleanupStack::PopAndDestroy(sinkFile);

  8084 	// Delete the file.

  8085 	// Remove the read only attribute.

  8086 	err = testFsSession.SetAtt(testFileName, 0, KEntryAttReadOnly);

  8087 	if (err != KErrNone)

  8088 		{

  8089 		INFO_PRINTF2(_L("File source Delete: Expecting KErrNone, actually got %d"), err);

  8090 		iTestResult = EFail;

  8091 		}

  8093 	sinkFile = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8094 	CleanupStack::PushL(sinkFile);

  8096 	TClipDeleteTestStep testStep9(sinkFile);

  8097 	DoTestStep(testStep9, _L("File sink Delete 9"), KErrNone);

  8099 	CleanupStack::PopAndDestroy(sinkFile);

  8101 	// Check that the file has actually been deleted.

  8102 	err = testFile.Open(testFsSession, testFileName, EFileRead);

  8103 	if (err != KErrNotFound)

  8104 		{

  8105 		testFile.Close();

  8107 		INFO_PRINTF2(_L("File sink Delete: Expecting KErrNotFound, actually got %d"), err);

  8108 		iTestResult = EFail;

  8109 		}

  8111 	// Re-create the file and delete it again.

  8112 	sinkFile = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8113 	CleanupStack::PushL(sinkFile);

  8114 	sinkFile->SinkPrimeL();

  8116 	TClipDeleteTestStep testStep10(sinkClip);

  8117 	DoTestStepWithAllocFail(testStep10, _L("File sink Delete 10"), KErrNone);

  8119 	CleanupStack::PopAndDestroy(sinkFile);

  8121 	// Check that the file has actually been deleted.

  8122 	err = testFile.Open(testFsSession, testFileName, EFileRead);

  8123 	if (err != KErrNotFound)

  8124 		{

  8125 		testFile.Close();

  8127 		INFO_PRINTF2(_L("File sink Delete: Expecting KErrNotFound, actually got %d"), err);

  8128 		iTestResult = EFail;

  8129 		}

  8131 	if (iFileFailureTestingEnabled)

  8132 		{

  8134 		// Re-create the file and delete it again.

  8135 		sinkFile = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8136 		CleanupStack::PushL(sinkFile);

  8137 		sinkFile->SinkPrimeL();

  8139 		TClipDeleteTestStep testStep11(sinkClip);

  8140 		DoTestStepWithFileFail(testStep11, _L("File sink Delete 11"), KErrNone);

  8142 		CleanupStack::PopAndDestroy(sinkFile);

  8144 		// Check that the file has actually been deleted.

  8145 		err = testFile.Open(testFsSession, testFileName, EFileRead);

  8146 		if (err != KErrNotFound)

  8147 			{

  8148 			testFile.Close();

  8150 			INFO_PRINTF2(_L("File sink Delete: Expecting KErrNotFound, actually got %d"), err);

  8151 			iTestResult = EFail;

  8152 			}

  8154 /*

  8155 		// DoTestStepWithAllocAndFileFail test is no longer run.

  8156 		// Code kept for reference purposes.

  8158 		// Re-create the file and delete it again.

  8159 		sinkFile = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8160 		CleanupStack::PushL(sinkFile);

  8161 		sinkFile->SinkPrimeL();

  8163 		TClipDeleteTestStep testStep12(sinkClip);

  8164 		DoTestStepWithAllocAndFileFail(testStep12, _L("File sink Delete"), KErrNone);

  8166 		CleanupStack::PopAndDestroy(sinkFile);

  8168 		// Check that the file has actually been deleted.

  8169 		err = testFile.Open(testFsSession, testFileName, EFileRead);

  8170 		if (err != KErrNotFound)

  8171 			{

  8172 			testFile.Close();

  8174 			INFO_PRINTF2(_L("File sink Delete: Expecting KErrNotFound, actually got %d"), err);

  8175 			iTestResult = EFail;

  8176 			}

  8177 */

  8178 		}

  8179 	CleanupStack::PopAndDestroy(); // testFsSession

  8181 	__MM_HEAP_MARKEND;

  8182 	return iTestResult;

  8183 	}

  8185 /**

  8186  *

  8187  * CTestStep_MMF_SRSSNK_U_0104 constructor

  8188  *

  8189  * @xxxx

  8190  *

  8191  */

  8192 CTestStep_MMF_SRSSNK_U_0104::CTestStep_MMF_SRSSNK_U_0104()

  8193 	{

  8194 	// store the name of this test case

  8195 	// this is the name that is used by the script file

  8196 	// Each test step initialises it's own name

  8197 	iTestStepName = _L("MM-MMF-SRSSNK-U-0104");

  8198 	}

  8200 /**

  8201  *

  8202  * CTestStep_MMF_SRSSNK_U_0104 destructor

  8203  *

  8204  * @xxxx

  8205  *

  8206  */

  8207 CTestStep_MMF_SRSSNK_U_0104::~CTestStep_MMF_SRSSNK_U_0104()

  8208 	{

  8209 	}

  8211 /**

  8212  *

  8213  * CTestStep_MMF_SRSSNK_U_0104

  8214  *

  8215  * Attempt to create file sink using invalid config data.

  8216  *

  8217  * @xxxx

  8218  */

  8219 _LIT(KTest104FileName1, "c:\\DefaultPathSink.dat"); // Valid but no path.

  8220 _LIT(KTest104FileName2, "c:\\DefaultPathNoExtSink"); // Valid but no path or ext.

  8221 _LIT(KTest104FileName3, ""); // Definitely not valid.

  8222 TVerdict CTestStep_MMF_SRSSNK_U_0104::DoTestStepL()

  8223 	{

  8224 	__MM_HEAP_MARK;

  8226 	// Initialise config data.

  8227 	TMMFFileConfig configDes;

  8228 	configDes().iPath = KTest104FileName1;

  8230 	// Test create the sink.

  8231 	TNewSinkTestStep testStep(KUidMmfFileSink, configDes);

  8232 	DoFileTest(testStep, _L("Construct file sink 104.1"), KErrNone);

  8234 	// Verify that the file has not been created.

  8235 	RFs testFsSession;

  8236 	User::LeaveIfError(testFsSession.Connect());

  8237 	CleanupClosePushL(testFsSession);

  8239 	RFile testFile;

  8240 	TInt err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  8241 	if (err != KErrNotFound)

  8242 		{

  8243 		testFile.Close();

  8245 		INFO_PRINTF2(_L("File sink create: Expecting KErrNone, actually got %d"), err);

  8246 		iTestResult = EFail;

  8247 		}

  8249 	TNewFileSinkTestStep testStep2(KUidMmfFileSink, configDes);

  8250 	DoFileTest(testStep2, _L("Construct file sink 104.2"), KErrNone);

  8252 	// Verify that the file has been created.

  8253 	err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  8254 	if (err != KErrNone)

  8255 		{

  8256 		INFO_PRINTF2(_L("File source create: Expecting KErrNone, actually got %d"), err);

  8257 		iTestResult = EFail;

  8258 		}

  8259 	testFile.Close();

  8261 	// Delete it.

  8262 	CMMFFile* sink = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8263 	CleanupStack::PushL(sink);

  8264 	User::LeaveIfError(sink->Delete());

  8265 	CleanupStack::PopAndDestroy(sink);

  8267 	if (iFileFailureTestingEnabled)

  8268 		{

  8269 		// Repeat test with file failure only. (Checks for file failure on creation)

  8270 		DoTestStepWithFileFail(testStep2, _L("Construct file sink 104.3"), KErrNone);

  8272 		// Delete it, now that we don't need it anymore.

  8273 		sink = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8274 		CleanupStack::PushL(sink);

  8275 		User::LeaveIfError(sink->Delete());

  8276 		CleanupStack::PopAndDestroy(sink);

  8277 		}

  8279 	configDes().iPath = KTest104FileName2;

  8280 	TNewSinkTestStep testStep3(KUidMmfFileSink, configDes);

  8281 	DoFileTest(testStep3, _L("Construct file sink 104.4"), KErrNone);

  8283 	// Verify that the file has not been created.

  8284 	err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  8285 	if (err != KErrNotFound)

  8286 		{

  8287 		testFile.Close();

  8289 		INFO_PRINTF2(_L("File sink create: Expecting KErrNone, actually got %d"), err);

  8290 		iTestResult = EFail;

  8291 		}

  8293 	TNewFileSinkTestStep testStep4(KUidMmfFileSink, configDes);

  8294 	DoFileTest(testStep4, _L("Construct file sink 104.5"), KErrNone);

  8296 	// Verify that the file has been created.

  8297 	err = testFile.Open(testFsSession, configDes().iPath, EFileRead);

  8298 	if (err != KErrNone)

  8299 		{

  8300 		INFO_PRINTF2(_L("File sink create: Expecting KErrNone, actually got %d"), err);

  8301 		iTestResult = EFail;

  8302 		}

  8303 	testFile.Close();

  8305 	// Delete it.

  8306 	sink = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8307 	CleanupStack::PushL(sink);

  8308 	User::LeaveIfError(sink->Delete());

  8309 	CleanupStack::PopAndDestroy(sink);

  8311 	if (iFileFailureTestingEnabled)

  8312 		{

  8313 		// Repeat test with file failure only. (Checks for file failure on creation)

  8314 		DoTestStepWithFileFail(testStep4, _L("Construct file sink 104.6"), KErrNone);

  8316 		// Delete it, now that we don't need it anymore.

  8317 		sink = STATIC_CAST(CMMFFile*, MDataSink::NewSinkL(KUidMmfFileSink, configDes));

  8318 		CleanupStack::PushL(sink);

  8319 		User::LeaveIfError(sink->Delete());

  8320 		CleanupStack::PopAndDestroy(sink);

  8321 		}

  8323 	configDes().iPath = KTest104FileName3;

  8324 	TNewSinkTestStep testStep5(KUidMmfFileSink, configDes);

  8325 	DoFileTest(testStep5, _L("Construct file sink 104.7"), KErrBadName);

  8327 	CleanupStack::PopAndDestroy(); // testFsSession

  8329 	__MM_HEAP_MARKEND;

  8330 	return iTestResult;

  8331 	}

  8333 /**

  8334  *

  8335  * CTestStep_MMF_SRSSNK_FileSourceMisc constructor

  8336  *

  8337  * @xxxx

  8338  *

  8339  */

  8340 CTestStep_MMF_SRSSNK_FileSourceMisc::CTestStep_MMF_SRSSNK_FileSourceMisc(TSourceType aSourceType)

  8341 	{

  8342 	// store the name of this test case

  8343 	// this is the name that is used by the script file

  8344 	// Each test step initialises it's own name

  8345 	iSourceType = aSourceType;

  8346 	ASSERT(iSourceType == ESourceTypeFile || iSourceType == ESourceTypeFileHandle);

  8347 	if (iSourceType == ESourceTypeFile)

  8348 		{

  8349 		iTestStepName = _L("MM-MMF-SRSSNK-U-0105");

  8350 		}

  8351 	else

  8352 		{

  8353 		iTestStepName = _L("MM-MMF-SRSSNK-U-0120");

  8354 		}

  8355 	}

  8357 /**

  8358  *

  8359  * CTestStep_MMF_SRSSNK_FileSourceMisc destructor

  8360  *

  8361  * @xxxx

  8362  *

  8363  */

  8364 CTestStep_MMF_SRSSNK_FileSourceMisc::~CTestStep_MMF_SRSSNK_FileSourceMisc()

  8365 	{

  8366 	}

  8368 /**

  8369  *

  8370  * CTestStep_MMF_SRSSNK_FileSourceMisc

  8371  *

  8372  * Functional test of file source.

  8373  * Misc. functions test.

  8374  *

  8375  * @xxxx

  8376  */

  8377 TVerdict CTestStep_MMF_SRSSNK_FileSourceMisc::DoTestStepL()

  8378 	{

  8379 	__MM_HEAP_MARK;

  8381 	// Initialise config data.

  8382 	TMMFFileConfig configFile;

  8383 	configFile().iPath = KTest101FileName;

  8385 	TInt fileSize;

  8386 	OpenFileL(KTest101FileName, EFileRead);

  8387 	User::LeaveIfError(iFile.Size(fileSize));

  8388 	CloseFile();

  8389 	User::LeaveIfError(iFs.Connect());

  8391 	// Create a valid buffer.

  8392 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8393 	CleanupStack::PushL(validBuffer);

  8395 	// Create a dummy sink.

  8396 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  8397 	CleanupStack::PushL(dummySink);

  8399 	// Create source.

  8400 	MDataSource* source = CreateFileSourceL(iSourceType, iFs, KTest101FileName);

  8401 	CleanupDeletePushL(source);

  8403 	// Test create source buffer.

  8404 	TCreateSourceBuffer1TestStep testStep(iSourceType, dummySink, KUidMmfDescriptorBuffer, ETrue);

  8405 	DoTest(testStep, _L("File source CreateSourceBuffer1"), KErrNotSupported);

  8407 	TCreateSourceBuffer2TestStep testStep2(iSourceType, dummySink, validBuffer, KUidMmfDescriptorBuffer, ETrue);

  8408 	DoTest(testStep2, _L("File source CreateSourceBuffer2"), KErrNotSupported);

  8410 	// Test default base class fns. (These should all do nothing)

  8411 	TSourceThreadLogonTestStep testStep3(source, dummySink);

  8412 	DoFileTest(testStep3, _L("File source SourceThreadLogon"), KErrNone);

  8414 	TNegotiateSourceTestStep testStep4(source, dummySink);

  8415 	DoTest(testStep4, _L("File source NegotiateSourceL"), KErrNone);

  8417 	source->SourcePrimeL();

  8418 	source->SourcePlayL();

  8419 	source->SourcePauseL();

  8420 	source->SourceStopL();

  8422 	TMMFPrioritySettings prioritySettings;

  8423 	source->SetSourcePrioritySettings(prioritySettings);

  8425 	// Test source log on.

  8426 	source->SourcePrimeL();

  8427 	TFileSourceThreadLogonTestStep testStep5(source, dummySink, fileSize);

  8428 	DoFileTest(testStep5, _L("File source SourceThreadLogon"), KErrNone);

  8430 	CleanupStack::PopAndDestroy(source); // source

  8432 	CleanupStack::PopAndDestroy(2, validBuffer); // dummySink, validBuffer

  8434 	__MM_HEAP_MARKEND;

  8435 	return iTestResult;

  8436 	}

  8438 /**

  8439  *

  8440  * CTestStep_MMF_SRSSNK_FileFillBuffer constructor

  8441  *

  8442  * @xxxx

  8443  *

  8444  */

  8445 CTestStep_MMF_SRSSNK_FileFillBuffer::CTestStep_MMF_SRSSNK_FileFillBuffer(TSourceType aSourceType)

  8446 	{

  8447 	iSourceType = aSourceType;

  8448 	ASSERT(iSourceType == ESourceTypeFile || iSourceType == ESourceTypeFileHandle);

  8449 	if (iSourceType == ESourceTypeFile)

  8450 		{

  8451 		iTestStepName = _L("MM-MMF-SRSSNK-U-0106");

  8452 		}

  8453 	else

  8454 		{

  8455 		iTestStepName = _L("MM-MMF-SRSSNK-U-0121");

  8456 		}

  8457 	}

  8459 /**

  8460  *

  8461  * CTestStep_MMF_SRSSNK_FileFillBuffer destructor

  8462  *

  8463  * @xxxx

  8464  *

  8465  */

  8466 CTestStep_MMF_SRSSNK_FileFillBuffer::~CTestStep_MMF_SRSSNK_FileFillBuffer()

  8467 	{

  8468 	}

  8470 /**

  8471  *

  8472  * CTestStep_MMF_SRSSNK_FileFillBuffer

  8473  *

  8474  * Functional test of descriptor source.

  8475  * FillBufferL() test.

  8476  *

  8477  * @xxxx

  8478  */

  8479 TVerdict CTestStep_MMF_SRSSNK_FileFillBuffer::DoTestStepL()

  8480 	{

  8481 	__MM_HEAP_MARK;

  8483 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  8484 	TPtr8 dataPtr(dataDes->Des());

  8485 	const TUint8* baseDataPtr = dataPtr.Ptr();

  8487 	// Initialise thread active scheduler.

  8488 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  8489 	CleanupStack::PushL(scheduler);

  8490 	CActiveScheduler::Install(scheduler);

  8492 	// Initialise config data.

  8493 	TFileName testFileName(KTest101FileName);

  8495 	// Read the data from the file.

  8496 	RFs testFsSession;

  8497 	User::LeaveIfError(testFsSession.Connect()) ;

  8498 	CleanupClosePushL(testFsSession);

  8500 	RFile testFile;

  8501 	User::LeaveIfError(testFile.Open(testFsSession, testFileName, EFileShareReadersOnly));

  8502 	CleanupClosePushL(testFile);

  8504 	User::LeaveIfError(testFile.Read(dataPtr));

  8505 	CleanupStack::PopAndDestroy(&testFile);

  8507 	// Create zero buffer.

  8508 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  8509 	CleanupStack::PushL(zeroBuffer);

  8511 	// Create big buffer.

  8512 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

  8513 	CleanupStack::PushL(bigBuffer);

  8515 	// Create valid buffer.

  8516 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8517 	CleanupStack::PushL(validBuffer);

  8519 	// Create dummy sink.

  8520 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  8521 	CleanupStack::PushL(dummySink);

  8523 	// Create file source.

  8524 	MDataSource* source = CreateFileSourceL(iSourceType, testFsSession, KTest101FileName);

  8525 	CleanupDeletePushL(source);

  8527 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8528 	source->SourcePrimeL();

  8530 	// Create test (invalid) buffer.

  8531 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  8532 	CleanupDeletePushL(testBuffer);

  8534 	// Test invalid FillBufferL.

  8535 	TFillBufferTestStep testStep(source, testBuffer, dummySink, dataPtr);

  8536 	DoFileTest(testStep, _L("File source FillBufferL"), KErrNotSupported);

  8537 	CleanupStack::PopAndDestroy(testBuffer);

  8539 	// Test valid FillBufferL.

  8541 	TFillBufferTestStep testStep2(source, validBuffer, dummySink, dataPtr, KTestBufferSize);

  8542 	testStep2.SetAsynchronousRead(ETrue);

  8543 	DoFileTestWithoutAllocFail(testStep2, _L("File source FillBufferL"), KErrNone, 2);

  8545 	CleanupStack::PopAndDestroy(source);

  8547 	TFileFillBufferTestStep testStep3(iSourceType, testFileName, validBuffer, dummySink, dataPtr, KTestBufferSize);

  8548 	testStep3.SetAsynchronousRead(ETrue);

  8549 	DoFileTest(testStep3, _L("File source FillBufferL"), KErrNone);

  8551 	// Test complete fill.

  8552 	source = CreateFileSourceL(iSourceType, testFsSession, KTest101FileName);

  8553 	CleanupDeletePushL(source);

  8555 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8556 	source->SourcePrimeL();

  8558 	TFillBufferTestStep testStep4(source, validBuffer, dummySink, dataPtr, KTestBufferSize);

  8559 	testStep4.SetAsynchronousRead(ETrue);

  8561 	const TUint8* sourcePtr = baseDataPtr;

  8562 	TInt bufferSize;

  8563 	do

  8564 		{

  8565 		testStep4.SetReadLength(Min(KTestBufferSize, KTestDataSize - (sourcePtr-baseDataPtr)));

  8566 		DoTestStep(testStep4, _L("File source FillBufferL"), KErrNone, 2);

  8568 		bufferSize = validBuffer->BufferSize();

  8569 		sourcePtr += bufferSize;

  8570 		} while (bufferSize == KTestBufferSize);

  8572 	if ((sourcePtr - dataPtr.Ptr()) != KTestDataSize)

  8573 		{

  8574 		INFO_PRINTF3(_L("File source FillBufferL: Source data ptr, expected %d, got %d"), KTestDataSize, sourcePtr - dataPtr.Ptr());

  8575 		iTestResult = EFail;

  8576 		}

  8578 	// Reset the source.

  8579 	source->SourceStopL();

  8580 	source->SourcePrimeL();

  8582 	if (iFileFailureTestingEnabled)

  8583 		{

  8584 		// Test complete fill with file fail.

  8585 		TFillBufferTestStep testStep5(source, validBuffer, dummySink, dataPtr, KTestBufferSize);

  8586 		testStep5.SetAsynchronousRead(ETrue);

  8588 		sourcePtr = baseDataPtr;

  8589 		do

  8590 			{

  8591 			testStep5.SetReadLength(Min(KTestBufferSize, KTestDataSize - (sourcePtr-baseDataPtr)));

  8592 			DoTestStepWithFileFail(testStep5, _L("File source FillBufferL"), KErrNone, 2);

  8594 			bufferSize = validBuffer->BufferSize();

  8595 			sourcePtr += bufferSize;

  8596 			} while (bufferSize == KTestBufferSize);

  8598 		if ((sourcePtr - dataPtr.Ptr()) != KTestDataSize)

  8599 			{

  8600 			INFO_PRINTF3(_L("File source FillBufferL: Source data ptr, expected %d, got %d"), KTestDataSize, sourcePtr - dataPtr.Ptr());

  8601 			iTestResult = EFail;

  8602 			}

  8604 		// Test additional fill request.

  8605 		testStep5.SetReadLength(0);

  8606 		DoFileTestWithoutAllocFail(testStep5, _L("File source FillBufferL"), KErrNone, 2);

  8607 		}

  8608 	CleanupStack::PopAndDestroy(source);

  8610 	// Test complete fill. (Single test version)

  8611 	TFileFillBuffer2TestStep testStep6(iSourceType, testFileName, validBuffer, dummySink, dataPtr);

  8612 	testStep6.SetAsynchronousRead(ETrue);

  8613 	DoFileTest(testStep6, _L("File source FillBufferL"), KErrNone);

  8615 	// Test multiple read requests.

  8616 	RPointerArray<CMMFBuffer> bufferArray;

  8617 	CleanupClosePushL(bufferArray);

  8619 	User::LeaveIfError(bufferArray.Append(validBuffer));

  8620 	TFileFillBuffer3TestStep testStep7(iSourceType, testFileName, &bufferArray, dummySink, dataPtr, KTestBufferSize);

  8621 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8623 	CMMFDescriptorBuffer* validBuffer2 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8624 	CleanupStack::PushL(validBuffer2);

  8625 	User::LeaveIfError(bufferArray.Append(validBuffer2));

  8626 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8628 	CMMFDescriptorBuffer* validBuffer3 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8629 	CleanupStack::PushL(validBuffer3);

  8630 	User::LeaveIfError(bufferArray.Append(validBuffer3));

  8631 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8633 	CMMFDescriptorBuffer* validBuffer4 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8634 	CleanupStack::PushL(validBuffer4);

  8635 	User::LeaveIfError(bufferArray.Append(validBuffer4));

  8636 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8638 	CMMFDescriptorBuffer* validBuffer5 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8639 	CleanupStack::PushL(validBuffer5);

  8640 	User::LeaveIfError(bufferArray.Append(validBuffer5));

  8641 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8643 	// Test multiple read requests that do not get completed.

  8644 	testStep7.SetMaxRequestCount(3);

  8645 	DoFileTest(testStep7, _L("File source FillBufferL"), KErrNone);

  8647 	// Test multiple read requests, checking correct deletion of completed requests.

  8648 	source = CreateFileSourceL(iSourceType, testFsSession, KTest101FileName);

  8649 	CleanupDeletePushL(source);

  8651 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8652 	source->SourcePrimeL();

  8654 	TFileFillBuffer4TestStep testStep8(source, &bufferArray, dummySink, dataPtr, KTestBufferSize);

  8655 	DoTestStep(testStep8, _L("File source FillBufferL"), KErrNone, 4);

  8657 	CleanupStack::PopAndDestroy(source);

  8659 	CleanupStack::PopAndDestroy(5, &bufferArray); // validBuffer5, 4, 3, 2, bufferArray

  8661 	// Test zero length read.

  8662 	TFileFillBufferTestStep testStep9(iSourceType, testFileName, zeroBuffer, dummySink, dataPtr);

  8663 	testStep9.SetAsynchronousRead(ETrue);

  8664 	DoFileTest(testStep9, _L("File source FillBufferL"), KErrNone);

  8666 	// Test over size read.

  8667 	TFileFillBufferTestStep testStep10(iSourceType, testFileName, bigBuffer, dummySink, dataPtr, KTestDataSize);

  8668 	testStep10.SetAsynchronousRead(ETrue);

  8669 	DoFileTest(testStep10, _L("File source FillBufferL"), KErrNone);

  8671 	CleanupStack::PopAndDestroy(7, dataDes); // dummySink, validBuffer, bigBuffer, zeroBuffer, testFsSession, scheduler, dataDes

  8673 	__MM_HEAP_MARKEND;

  8674 	return iTestResult;

  8675 	}

  8677 /**

  8678  *

  8679  * CTestStep_MMF_SRSSNK_U_0107 constructor

  8680  *

  8681  * @xxxx

  8682  *

  8683  */

  8685 CTestStep_MMF_SRSSNK_U_0107::CTestStep_MMF_SRSSNK_U_0107()

  8686 : CTestStep_MMF_SRSSNK(EFalse)

  8687 	{

  8688 	// store the name of this test case

  8689 	// this is the name that is used by the script file

  8690 	// Each test step initialises it's own name

  8691 	iTestStepName = _L("MM-MMF-SRSSNK-U-0107");

  8692 	}

  8694 /**

  8695  *

  8696  * CTestStep_MMF_SRSSNK_U_0107 destructor

  8697  *

  8698  * @xxxx

  8699  *

  8700  */

  8701 CTestStep_MMF_SRSSNK_U_0107::~CTestStep_MMF_SRSSNK_U_0107()

  8702 	{

  8703 	}

  8705 /**

  8706  *

  8707  * CTestStep_MMF_SRSSNK_U_0107

  8708  *

  8709  * Functional test of file source.

  8710  * BufferEmptiedL() panic test.

  8711  *

  8712  * @xxxx

  8713  */

  8714 TVerdict CTestStep_MMF_SRSSNK_U_0107::DoTestStepL()

  8715 	{

  8716 	__MM_HEAP_MARK;

  8718 	// This test fails if running a debug StdSourcesAndSinks dll.

  8719 	// So only perform the test on target.

  8721 	// Initialise config data.

  8722 	TMMFFileConfig configDes;

  8723 	configDes().iPath = KTest101FileName;

  8725 	// Create valid buffer.

  8726 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8727 	CleanupStack::PushL(validBuffer);

  8729 	// Create source file.

  8730 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

  8731 	CleanupDeletePushL(source);

  8733 	// Test BufferEmptiedL

  8734 	source->BufferEmptiedL(validBuffer);

  8736 	CleanupStack::PopAndDestroy(2, validBuffer); // source, validBuffer

  8738 	__MM_HEAP_MARKEND;

  8739 	return iTestResult;

  8740 	}

  8742 /**

  8743  *

  8744  * CTestStep_MMF_SRSSNK_FileReadBuffer constructor

  8745  *

  8746  * @xxxx

  8747  *

  8748  */

  8749 CTestStep_MMF_SRSSNK_FileReadBuffer::CTestStep_MMF_SRSSNK_FileReadBuffer(TSourceType aSourceType)

  8750 	{

  8751 	ASSERT(aSourceType == ESourceTypeFile || aSourceType == ESourceTypeFileHandle);

  8752 	iSourceType = aSourceType;

  8753 	if (iSourceType == ESourceTypeFile)

  8754 		{

  8755 		iTestStepName = _L("MM-MMF-SRSSNK-U-0108");

  8756 		}

  8757 	else

  8758 		{

  8759 		iTestStepName = _L("MM-MMF-SRSSNK-U-0122");

  8760 		}

  8761 	}

  8763 /**

  8764  *

  8765  * CTestStep_MMF_SRSSNK_FileReadBuffer destructor

  8766  *

  8767  * @xxxx

  8768  *

  8769  */

  8770 CTestStep_MMF_SRSSNK_FileReadBuffer::~CTestStep_MMF_SRSSNK_FileReadBuffer()

  8771 	{

  8772 	}

  8774 /**

  8775  *

  8776  * CTestStep_MMF_SRSSNK_FileReadBuffer

  8777  *

  8778  * Functional test of file source.

  8779  * ReadBufferL() test.

  8780  *

  8781  * @xxxx

  8782  */

  8783 TVerdict CTestStep_MMF_SRSSNK_FileReadBuffer::DoTestStepL()

  8784 	{

  8785 	__MM_HEAP_MARK;

  8787 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  8788 	TPtr8 dataPtr(dataDes->Des());

  8790 	// Initialise thread active scheduler.

  8791 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  8792 	CleanupStack::PushL(scheduler);

  8793 	CActiveScheduler::Install(scheduler);

  8795 	// Initialise config data.

  8796 	TFileName testFileName(KTest101FileName);

  8798 	// Read the data from the file.

  8799 	RFs testFsSession;

  8800 	User::LeaveIfError(testFsSession.Connect()) ;

  8801 	CleanupClosePushL(testFsSession);

  8803 	RFile testFile;

  8804 	User::LeaveIfError(testFile.Open(testFsSession, testFileName, EFileShareReadersOnly));

  8805 	CleanupClosePushL(testFile);

  8807 	User::LeaveIfError(testFile.Read(dataPtr));

  8808 	CleanupStack::PopAndDestroy(&testFile);

  8810 	// Create zero buffer.

  8811 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  8812 	CleanupStack::PushL(zeroBuffer);

  8814 	// Create big buffer.

  8815 	CMMFDescriptorBuffer* bigBuffer = CMMFDescriptorBuffer::NewL(KTestOverDataSize);

  8816 	CleanupStack::PushL(bigBuffer);

  8818 	// Create valid buffer.

  8819 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8820 	CleanupStack::PushL(validBuffer);

  8822 	// Create dummy sink.

  8823 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

  8824 	CleanupStack::PushL(dummySink);

  8826 	// Create source file.

  8827 	CMMFClip* source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, testFsSession, KTest101FileName));

  8828 	CleanupStack::PushL(source);

  8830 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8831 	source->SourcePrimeL();

  8833 	// Test ReadBufferL (these tests should fail)

  8834 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  8835 	CleanupStack::PushL(testBuffer);

  8837 	TClipReadBufferTestStep testStep(source, testBuffer, 0, dummySink, dataPtr);

  8838 	DoFileTest(testStep, _L("File source ReadBufferL(1)"), KErrNotSupported);

  8840 	TClipReadBuffer2TestStep testStep2(source, testBuffer, 0, dummySink, dataPtr, KTestBufferSize);

  8841 	DoFileTest(testStep2, _L("File source ReadBufferL(2)"), KErrNotSupported);

  8843 	TClipReadBuffer3TestStep testStep3(source, testBuffer, 0, dataPtr, KTestBufferSize);

  8844 	DoFileTest(testStep3, _L("File source ReadBufferL(3)"), KErrNotSupported);

  8845 	CleanupStack::PopAndDestroy(testBuffer);

  8847 	// Test reading from the beginning, middle and end.

  8848 	TClipReadBufferTestStep testStep4(source, validBuffer, 0, dummySink, dataPtr, KTestReadSize);

  8849 	testStep4.SetAsynchronousRead(ETrue);

  8850 	DoFileTestWithoutAllocFail(testStep4, _L("File source ReadBufferL(4)"), KErrNone, 2);

  8851 	CleanupStack::PopAndDestroy(source);

  8853 	TFileReadBufferTestStep testStep5(iSourceType, testFileName, validBuffer, 0, dummySink, dataPtr, KTestReadSize);

  8854 	testStep5.SetAsynchronousRead(ETrue);

  8855 	DoFileTest(testStep5, _L("File source ReadBufferL(5)"), KErrNone);

  8857 	testStep5.SetPosition(1);

  8858 	DoFileTest(testStep5, _L("File source ReadBufferL(6)"), KErrNone);

  8860 	testStep5.SetPosition(KTestDataSize/2);

  8861 	DoFileTest(testStep5, _L("File source ReadBufferL(7)"), KErrNone);

  8863 	testStep5.SetPosition(KTestDataSize/2 + 1);

  8864 	DoFileTest(testStep5, _L("File source ReadBufferL(8)"), KErrNone);

  8866 	TFileReadBuffer4TestStep testStep6(iSourceType, testFileName, validBuffer, KTestDataSize - 10, dummySink, dataPtr, KTestReadSize);

  8867 	testStep6.SetAsynchronousRead(ETrue);

  8868 	testStep6.SetExpectedReadLength(10);

  8869 	DoFileTest(testStep6, _L("File source ReadBufferL(9)"), KErrNone);

  8871 	testStep6.SetPosition(KTestDataSize);

  8872 	testStep6.SetExpectedReadLength(0);

  8873 	DoFileTest(testStep6, _L("File source ReadBufferL(10)"), KErrNone);

  8875 	testStep6.SetPosition(KTestDataSize + 2);

  8876 	DoFileTest(testStep6, _L("File source ReadBufferL(11)"), KErrNone);

  8878 	// Attempt to read nothing.

  8879 	testStep6.SetPosition(0);

  8880 	testStep6.SetReadLength(0);

  8881 	DoFileTest(testStep6, _L("File source ReadBufferL(12)"), KErrNone);

  8883 	// Attempt to read more data than can fit in the buffer.

  8884 	testStep6.SetReadLength(KTestOverReadSize);

  8885 	DoFileTest(testStep6, _L("File source ReadBufferL(13)"), KErrOverflow);

  8887 	// Attempt to read into a zero length buffer.

  8888 	TFileReadBufferTestStep testStep7(iSourceType, testFileName, zeroBuffer, 0, dummySink, dataPtr);

  8889 	testStep7.SetAsynchronousRead(ETrue);

  8890 	DoFileTest(testStep7, _L("File source ReadBufferL(14)"), KErrNone);

  8892 	// Attempt to read more data than present in the source.

  8893 	TFileReadBuffer4TestStep testStep8(iSourceType, testFileName, bigBuffer, 0, dummySink, dataPtr, KTestOverDataSize);

  8894 	testStep8.SetAsynchronousRead(ETrue);

  8895 	testStep8.SetExpectedReadLength(KTestDataSize);

  8896 	DoFileTest(testStep8, _L("File source ReadBufferL(15)"), KErrNone);

  8898 	// Repeat reads without supplying the length to read.

  8899 	source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, testFsSession, KTest101FileName));

  8900 	CleanupStack::PushL(source);

  8902 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8903 	source->SourcePrimeL();

  8905 	TClipReadBuffer2TestStep testStep9(source, validBuffer, 0, dummySink, dataPtr, KTestBufferSize);

  8906 	testStep9.SetAsynchronousRead(ETrue);

  8907 	DoFileTestWithoutAllocFail(testStep9, _L("File source ReadBufferL(16)"), KErrNone, 2);

  8908 	CleanupStack::PopAndDestroy(source);

  8910 	TFileReadBuffer2TestStep testStep10(iSourceType, testFileName, validBuffer, 0, dummySink, dataPtr, KTestBufferSize);

  8911 	testStep10.SetAsynchronousRead(ETrue);

  8912 	DoFileTest(testStep10, _L("File source ReadBufferL(17)"), KErrNone);

  8914 	testStep10.SetPosition(1);

  8915 	DoFileTest(testStep10, _L("File source ReadBufferL(18)"), KErrNone);

  8917 	testStep10.SetPosition(KTestDataSize/2);

  8918 	DoFileTest(testStep10, _L("File source ReadBufferL(19)"), KErrNone);

  8920 	testStep10.SetPosition(KTestDataSize/2 + 1);

  8921 	DoFileTest(testStep10, _L("File source ReadBufferL(20)"), KErrNone);

  8923 	testStep10.SetPosition(KTestDataSize - 10);

  8924 	testStep10.SetReadLength(10);

  8925 	DoFileTest(testStep10, _L("File source ReadBufferL(21)"), KErrNone);

  8927 	testStep10.SetPosition(KTestDataSize);

  8928 	testStep10.SetReadLength(0);

  8929 	DoFileTest(testStep10, _L("File source ReadBufferL(22)"), KErrNone);

  8931 	testStep10.SetPosition(KTestDataSize + 2);

  8932 	DoFileTest(testStep10, _L("File source ReadBufferL(23)"), KErrNone);

  8934 	TFileReadBuffer2TestStep testStep11(iSourceType, testFileName, zeroBuffer, 0, dummySink, dataPtr, 0);

  8935 	testStep11.SetAsynchronousRead(ETrue);

  8936 	DoFileTest(testStep11, _L("File source ReadBufferL(24)"), KErrNone);

  8938 	TFileReadBuffer2TestStep testStep12(iSourceType, testFileName, bigBuffer, 0, dummySink, dataPtr, KTestDataSize);

  8939 	testStep12.SetAsynchronousRead(ETrue);

  8940 	DoFileTest(testStep12, _L("File source ReadBufferL(25)"), KErrNone);

  8942 	// Repeat reads without supplying the length, or a sink.

  8943 	source = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, testFsSession, KTest101FileName));

  8944 	CleanupStack::PushL(source);

  8946 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

  8947 	source->SourcePrimeL();

  8949 	TClipReadBuffer3TestStep testStep13(source, validBuffer, 0, dataPtr, KTestBufferSize);

  8950 	DoFileTest(testStep13, _L("File source ReadBufferL(26)"), KErrNone);

  8951 	CleanupStack::PopAndDestroy(source);

  8953 	TFileReadBuffer3TestStep testStep14(iSourceType, testFileName, validBuffer, 0, dataPtr, KTestBufferSize);

  8954 	DoFileTest(testStep14, _L("File source ReadBufferL(27)"), KErrNone);

  8956 	testStep14.SetPosition(1);

  8957 	DoFileTest(testStep14, _L("File source ReadBufferL(28)"), KErrNone);

  8959 	testStep14.SetPosition(KTestDataSize/2);

  8960 	DoFileTest(testStep14, _L("File source ReadBufferL(29)"), KErrNone);

  8962 	testStep14.SetPosition(KTestDataSize/2 + 1);

  8963 	DoFileTest(testStep14, _L("File source ReadBufferL(30)"), KErrNone);

  8965 	testStep14.SetPosition(KTestDataSize - 10);

  8966 	testStep14.SetReadLength(10);

  8967 	DoFileTest(testStep14, _L("File source ReadBufferL(31)"), KErrNone);

  8969 	testStep14.SetPosition(KTestDataSize);

  8970 	testStep14.SetReadLength(0);

  8971 	DoFileTest(testStep14, _L("File source ReadBufferL(32)"), KErrNone);

  8973 	testStep14.SetPosition(KTestDataSize + 2);

  8974 	DoFileTest(testStep14, _L("File source ReadBufferL(33)"), KErrNone);

  8976 	TFileReadBuffer3TestStep testStep15(iSourceType, testFileName, zeroBuffer, 0, dataPtr, 0);

  8977 	DoFileTest(testStep15, _L("File source ReadBufferL(34)"), KErrNone);

  8979 	TFileReadBuffer3TestStep testStep16(iSourceType, testFileName, bigBuffer, 0, dataPtr, KTestDataSize);

  8980 	DoFileTest(testStep16, _L("File source ReadBufferL(35)"), KErrNone);

  8982 	// Test multiple read requests.

  8983 	RPointerArray<CMMFBuffer> bufferArray;

  8984 	CleanupClosePushL(bufferArray);

  8986 	User::LeaveIfError(bufferArray.Append(validBuffer));

  8987 	TFileReadBuffer5TestStep testStep17(iSourceType, testFileName, &bufferArray, 0, dummySink, dataPtr, KTestReadSize);

  8988 	TFileReadBuffer6TestStep testStep18(iSourceType, testFileName, &bufferArray, 0, dummySink, dataPtr, KTestBufferSize);

  8989 	DoFileTest(testStep17, _L("File source ReadBufferL(36)"), KErrNone);

  8990 	DoFileTest(testStep18, _L("File source ReadBufferL(37)"), KErrNone);

  8992 	CMMFDescriptorBuffer* validBuffer2 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8993 	CleanupStack::PushL(validBuffer2);

  8994 	User::LeaveIfError(bufferArray.Append(validBuffer2));

  8995 	DoFileTest(testStep17, _L("File source ReadBufferL(38)"), KErrNone);

  8996 	DoFileTest(testStep18, _L("File source ReadBufferL(39)"), KErrNone);

  8998 	CMMFDescriptorBuffer* validBuffer3 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  8999 	CleanupStack::PushL(validBuffer3);

  9000 	User::LeaveIfError(bufferArray.Append(validBuffer3));

  9001 	DoFileTest(testStep17, _L("File source ReadBufferL(40)"), KErrNone);

  9002 	DoFileTest(testStep18, _L("File source ReadBufferL(41)"), KErrNone);

  9004 	CMMFDescriptorBuffer* validBuffer4 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9005 	CleanupStack::PushL(validBuffer4);

  9006 	User::LeaveIfError(bufferArray.Append(validBuffer4));

  9007 	DoFileTest(testStep17, _L("File source ReadBufferL(42)"), KErrNone);

  9008 	DoFileTest(testStep18, _L("File source ReadBufferL(43)"), KErrNone);

  9010 	CMMFDescriptorBuffer* validBuffer5 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9011 	CleanupStack::PushL(validBuffer5);

  9012 	User::LeaveIfError(bufferArray.Append(validBuffer5));

  9013 	DoFileTest(testStep17, _L("File source ReadBufferL(44)"), KErrNone);

  9014 	DoFileTest(testStep18, _L("File source ReadBufferL(45)"), KErrNone);

  9016 	// Test multiple read requests that do not get completed.

  9017 	testStep17.SetMaxRequestCount(3);

  9018 	DoFileTest(testStep17, _L("File source FillBufferL(46)"), KErrNone);

  9020 	testStep18.SetMaxRequestCount(3);

  9021 	DoFileTest(testStep18, _L("File source FillBufferL(47)"), KErrNone);

  9023 	// Test multiple read requests, checking correct deletion of completed requests.

  9024 	CMMFClip* clip = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, testFsSession, KTest101FileName));

  9025 	CleanupDeletePushL(clip);

  9027 	User::LeaveIfError(clip->SourceThreadLogon(*dummySink));

  9028 	clip->SourcePrimeL();

  9030 	TFileReadBuffer7TestStep testStep19(clip, &bufferArray, 0, dummySink, dataPtr, KTestBufferSize);

  9031 	DoTestStep(testStep19, _L("File source FillBufferL(48)"), KErrNone, 4);

  9033 	CleanupStack::PopAndDestroy(clip);

  9035 	clip = STATIC_CAST(CMMFClip*, CreateFileSourceL(iSourceType, testFsSession, KTest101FileName));

  9036 	CleanupDeletePushL(clip);

  9038 	User::LeaveIfError(clip->SourceThreadLogon(*dummySink));

  9039 	clip->SourcePrimeL();

  9041 	TFileReadBuffer8TestStep testStep20(clip, &bufferArray, 0, dummySink, dataPtr, KTestBufferSize);

  9042 	DoTestStep(testStep20, _L("File source FillBufferL(49)"), KErrNone, 4);

  9044 	CleanupStack::PopAndDestroy(clip);

  9046 	CleanupStack::PopAndDestroy(12, dataDes); // validBuffer5, 4, 3, 2, bufferArray, dummySink, bigBuffer, zeroBuffer, validBuffer, testFsSession, scheduler, dataDes

  9048 	__MM_HEAP_MARKEND;

  9049 	return iTestResult;

  9050 	}

  9052 /**

  9053  *

  9054  * CTestStep_MMF_SRSSNK_U_0109 constructor

  9055  *

  9056  * @xxxx

  9057  *

  9058  */

  9059 CTestStep_MMF_SRSSNK_U_0109::CTestStep_MMF_SRSSNK_U_0109()

  9060 	{

  9061 	// store the name of this test case

  9062 	// this is the name that is used by the script file

  9063 	// Each test step initialises it's own name

  9064 	iTestStepName = _L("MM-MMF-SRSSNK-U-0109");

  9065 	}

  9067 /**

  9068  *

  9069  * CTestStep_MMF_SRSSNK_U_0109 destructor

  9070  *

  9071  * @xxxx

  9072  *

  9073  */

  9075 CTestStep_MMF_SRSSNK_U_0109::~CTestStep_MMF_SRSSNK_U_0109()

  9076 	{

  9077 	}

  9079 /**

  9080  *

  9081  * CTestStep_MMF_SRSSNK_U_0109

  9082  *

  9083  * Functional test of file source.

  9084  * Source custom commands test.

  9085  *

  9086  * @xxxx

  9087  */

  9088 TVerdict CTestStep_MMF_SRSSNK_U_0109::DoTestStepL()

  9089 	{

  9090 	__MM_HEAP_MARK;

  9092 	// Initialise config data.

  9093 	TMMFFileConfig configDes;

  9094 	configDes().iPath = KTest101FileName;

  9096 	TUid testControllerUid = { KMmfTestControllerUid };

  9097 	RMMFController dummyController;

  9098 	TMMFPrioritySettings prioritySettings;

  9099 	TMMFMessageDestinationPckg destination;

  9100 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

  9101 	CleanupClosePushL(dummyController);

  9103 	TBuf8<1> dummyArgs;

  9104 	User::LeaveIfError(dummyController.AddDataSource(KUidMmfFileSource, configDes));

  9105 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSource, dummyArgs, dummyArgs);

  9106 	if (err != KErrNotSupported)

  9107 		{

  9108 		INFO_PRINTF2(_L("File source SourceCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

  9109 		iTestResult = EFail;

  9110 		}

  9112 	CleanupStack::PopAndDestroy(); // dummyController

  9114 	__MM_HEAP_MARKEND;

  9115 	return iTestResult;

  9116 	}

  9118 /**

  9119  *

  9120  * CTestStep_MMF_SRSSNK_FileSinkMisc constructor

  9121  *

  9122  * @xxxx

  9123  *

  9124  */

  9125 CTestStep_MMF_SRSSNK_FileSinkMisc::CTestStep_MMF_SRSSNK_FileSinkMisc(TSinkType aSinkType)

  9126 	:iSinkType(aSinkType)

  9127 	{

  9128 	if (iSinkType == ESinkTypeFile)

  9129 		{

  9130 		iTestStepName = _L("MM-MMF-SRSSNK-U-0110");

  9131 		}

  9132 	else

  9133 		{

  9134 		iTestStepName = _L("MM-MMF-SRSSNK-U-0130");

  9135 		}

  9136 	}

  9138 /**

  9139  *

  9140  * CTestStep_MMF_SRSSNK_FileSinkMisc destructor

  9141  *

  9142  * @xxxx

  9143  *

  9144  */

  9145 CTestStep_MMF_SRSSNK_FileSinkMisc::~CTestStep_MMF_SRSSNK_FileSinkMisc()

  9146 	{

  9147 	}

  9149 /**

  9150  *

  9151  * CTestStep_MMF_SRSSNK_FileSinkMisc

  9152  *

  9153  * Functional test of file sink.

  9154  * Misc. functions test.

  9155  *

  9156  * @xxxx

  9157  */

  9158 TVerdict CTestStep_MMF_SRSSNK_FileSinkMisc::DoTestStepL()

  9159 	{

  9160 	__MM_HEAP_MARK;

  9162 	TFileName testFileName(KTest101FileName);

  9164 	// Get file info.

  9165 	RFs testFsSession;

  9166 	User::LeaveIfError(testFsSession.Connect()) ;

  9167 	CleanupClosePushL(testFsSession);

  9169 	// Get the size of the test file.

  9170 	RFile testFile;

  9171 	User::LeaveIfError(testFile.Open(testFsSession, testFileName, EFileRead));

  9172 	CleanupClosePushL(testFile);

  9174 	TInt fileSize;

  9175 	User::LeaveIfError(testFile.Size(fileSize));

  9176 	CleanupStack::PopAndDestroy(&testFile);

  9178 	// Create dummy source.

  9179 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  9180 	CleanupStack::PushL(dummySource);

  9182 	// Create sink.

  9183 	MDataSink* sink = CreateFileSinkL(iSinkType, testFsSession, testFileName);

  9184 	CleanupDeletePushL(sink);

  9186 	// Test create sink buffer. (This should fail)

  9187 	TCreateSinkBufferTestStep0 testStep(sink, KUidMmfDescriptorBuffer, ETrue, NULL);

  9188 	DoTest(testStep, _L("File sink CreateSinkBuffer"), KErrNotSupported);

  9190 	// Test default base class fns. (These should all do nothing)

  9191 	TSinkThreadLogonTestStep testStep2(sink, dummySource);

  9192 	DoFileTest(testStep2, _L("File sink SinkThreadLogon"), KErrNone);

  9194 	TNegotiateTestStep testStep3(sink, dummySource);

  9195 	DoTest(testStep3, _L("File sink NegotiateL"), KErrNone);

  9197 	sink->SinkPrimeL();

  9198 	sink->SinkPlayL();

  9199 	sink->SinkPauseL();

  9200 	sink->SinkStopL();

  9202 	TMMFPrioritySettings prioritySettings;

  9203 	sink->SetSinkPrioritySettings(prioritySettings);

  9205 	// Test sink log on.

  9206 	sink->SinkPrimeL();

  9207 	TFileSinkThreadLogonTestStep testStep5(sink, dummySource, fileSize);

  9208 	DoFileTest(testStep5, _L("File sink SinkThreadLogon"), KErrNone);

  9210 	CleanupStack::PopAndDestroy(sink);

  9212 	CleanupStack::PopAndDestroy(2, &testFsSession); //dummySource, testFsSession

  9214 	__MM_HEAP_MARKEND;

  9215 	return iTestResult;

  9216 	}

  9219 /**

  9220  *

  9221  * CTestStep_MMF_SRSSNK_FileEmptyBuffer constructor

  9222  *

  9223  * @xxxx

  9224  *

  9225  */

  9226 CTestStep_MMF_SRSSNK_FileEmptyBuffer::CTestStep_MMF_SRSSNK_FileEmptyBuffer(TSinkType aSinkType)

  9227 	: iSinkType(aSinkType)

  9228 	{

  9229 	if (iSinkType == ESinkTypeFile)

  9230 		{

  9231 		iTestStepName = _L("MM-MMF-SRSSNK-U-0111");

  9232 		}

  9233 	else

  9234 		{

  9235 		iTestStepName = _L("MM-MMF-SRSSNK-U-0131");

  9236 		}

  9237 	}

  9239 /**

  9240  *

  9241  * CTestStep_MMF_SRSSNK_FileEmptyBuffer destructor

  9242  *

  9243  * @xxxx

  9244  *

  9245  */

  9246 CTestStep_MMF_SRSSNK_FileEmptyBuffer::~CTestStep_MMF_SRSSNK_FileEmptyBuffer()

  9247 	{

  9248 	}

  9250 /**

  9251  *

  9252  * CTestStep_MMF_SRSSNK_FileEmptyBuffer

  9253  *

  9254  * There was a flaw in that a failure in DoFileTest and its variants is overlooked.

  9255  * Each time it is called the status of iTestResult must be checked before it's

  9256  * overwritten. It is set to EPass again so that false negatives aren't recorded.

  9257  *

  9258  * The success of this test step depends on the 'failure' variable.

  9259  *

  9260  * EmptyBufferL() test.

  9261  *

  9262  * @xxxx

  9263  */

  9264 _LIT(KTest111FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile4.dat");

  9265 TVerdict CTestStep_MMF_SRSSNK_FileEmptyBuffer::DoTestStepL()

  9266 	{

  9267 	__MM_HEAP_MARK;

  9269 	TBool failure = EFalse;

  9271 	// Create source buffer.

  9272 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  9273 	TPtr8 dataPtr(dataDes->Des());

  9275 	// Initialise thread active scheduler.

  9276 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  9277 	CleanupStack::PushL(scheduler);

  9278 	CActiveScheduler::Install(scheduler);

  9280 	// Set the filename and create a file session.

  9281 	TFileName testFileName(KTest111FileName);

  9283 	RFs testFsSession;

  9284 	User::LeaveIfError(testFsSession.Connect());

  9285 	CleanupClosePushL(testFsSession);

  9287 	// Delete the test file (might exist from last time)

  9288 	testFsSession.Delete(testFileName);

  9290 	// Create a dummy source.

  9291 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  9292 	CleanupStack::PushL(dummySource);

  9294 	// Create a zero length buffer.

  9295 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  9296 	CleanupStack::PushL(zeroBuffer);

  9298 	// Create a valid buffer.

  9299 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9300 	CleanupStack::PushL(validBuffer);

  9302 	// Set the length to write.

  9303 	validBuffer->Data().SetLength(KTestWriteSize);

  9305 	// Create the sink.

  9306 	MDataSink* sink = CreateFileSinkL(iSinkType, testFsSession, testFileName);

  9307 	CleanupDeletePushL(sink);

  9309 	// Create a test (invalid) buffer.

  9310 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  9311 	CleanupStack::PushL(testBuffer);

  9313 	// Test EmptyBufferL.

  9314 	TFileEmptyBufferTestStep testStep(sink, testBuffer, dummySource, testFsSession, testFileName, dataPtr);

  9315 	DoFileTest(testStep, _L("File sink EmptyBufferL(1)"), KErrNotSupported);

  9316 	CleanupStack::PopAndDestroy(testBuffer);

  9317 	if (iTestResult != EPass)

  9318 		{

  9319 		INFO_PRINTF1(_L("File Sink EmptyBufferL(1) failed"));

  9320 		failure = ETrue;

  9321 		iTestResult = EPass;

  9322 		}

  9324 	// Test valid EmptyBufferL.

  9325 	TFileEmptyBufferTestStep testStep2(sink, validBuffer, dummySource, testFsSession, testFileName, dataPtr);

  9326 	testStep2.SetAsynchronousWrite(ETrue);

  9327 	DoFileTestWithoutAllocFail(testStep2, _L("File sink EmptyBufferL(2)"), KErrNone, 2);

  9328 	if (iTestResult != EPass)

  9329 		{

  9330 		INFO_PRINTF1(_L("File Sink EmptyBufferL(2) failed"));

  9331 		failure = ETrue;

  9332 		iTestResult = EPass;

  9333 		}

  9335 	CleanupStack::PopAndDestroy(sink);

  9337 	TFileEmptyBuffer2TestStep testStep3(iSinkType, validBuffer, dummySource, testFsSession, testFileName, dataPtr);

  9338 	testStep3.SetAsynchronousWrite(ETrue);

  9339 	DoFileTest(testStep3, _L("File sink EmptyBufferL(3)"), KErrNone);

  9340 	if (iTestResult != EPass)

  9341 		{

  9342 		INFO_PRINTF1(_L("File Sink EmptyBufferL(3) failed"));

  9343 		failure = ETrue;

  9344 		iTestResult = EPass;

  9345 		}

  9347 	// Test complete empty.

  9348 	TFileEmptyBuffer3TestStep testStep4(iSinkType, validBuffer, dummySource, testFsSession, testFileName, dataPtr);

  9349 	testStep4.SetAsynchronousWrite(ETrue);

  9350 	DoFileTest(testStep4, _L("File sink EmptyBufferL(4)"), KErrNone);

  9351 	if (iTestResult != EPass)

  9352 		{

  9353 		INFO_PRINTF1(_L("File Sink EmptyBufferL(4) failed"));

  9354 		failure = ETrue;

  9355 		iTestResult = EPass;

  9356 		}

  9358 	// Test multiple write requests.

  9359 	RPointerArray<CMMFBuffer> bufferArray;

  9360 	CleanupClosePushL(bufferArray);

  9362 	User::LeaveIfError(bufferArray.Append(validBuffer));

  9363 	TFileEmptyBuffer4TestStep testStep5(iSinkType, &bufferArray, dummySource, testFsSession, testFileName, dataPtr);

  9364 	testStep5.SetAsynchronousWrite(ETrue);

  9365 	testStep5.SetWriteLength(KTestWriteSize);

  9366 	DoFileTest(testStep5, _L("File sink EmptyBufferL(5)"), KErrNone);

  9367 	if (iTestResult != EPass)

  9368 		{

  9369 		INFO_PRINTF1(_L("File Sink EmptyBufferL(5) failed"));

  9370 		failure = ETrue;

  9371 		iTestResult = EPass;

  9372 		}

  9374 	// Create valid buffer 2.

  9375 	CMMFDescriptorBuffer* validBuffer2 = CMMFDescriptorBuffer::NewL(KTestWriteSize);

  9376 	CleanupStack::PushL(validBuffer2);

  9378 	// Set the length to write.

  9379 	validBuffer2->Data().SetLength(KTestWriteSize);

  9380 	User::LeaveIfError(bufferArray.Append(validBuffer2));

  9381 	DoFileTest(testStep5, _L("File sink EmptyBufferL(6)"), KErrNone);

  9382 	if (iTestResult != EPass)

  9383 		{

  9384 		INFO_PRINTF1(_L("File Sink EmptyBufferL(6) failed"));

  9385 		failure = ETrue;

  9386 		iTestResult = EPass;

  9387 		}

  9389 	// Create valid buffer 3.

  9390 	CMMFDescriptorBuffer* validBuffer3 = CMMFDescriptorBuffer::NewL(KTestWriteSize);

  9391 	CleanupStack::PushL(validBuffer3);

  9393 	// Set the length to write.

  9394 	validBuffer3->Data().SetLength(KTestWriteSize);

  9396 	User::LeaveIfError(bufferArray.Append(validBuffer3));

  9397 	DoFileTest(testStep5, _L("File sink EmptyBufferL(7)"), KErrNone);

  9398 	if (iTestResult != EPass)

  9399 		{

  9400 		INFO_PRINTF1(_L("File Sink EmptyBufferL(7) failed"));

  9401 		failure = ETrue;

  9402 		iTestResult = EPass;

  9403 		}

  9405 	// Create valid buffer 4.

  9406 	CMMFDescriptorBuffer* validBuffer4 = CMMFDescriptorBuffer::NewL(KTestWriteSize);

  9407 	CleanupStack::PushL(validBuffer4);

  9409 	// Set the length to write.

  9410 	validBuffer4->Data().SetLength(KTestWriteSize);

  9412 	User::LeaveIfError(bufferArray.Append(validBuffer4));

  9413 	DoFileTest(testStep5, _L("File sink EmptyBufferL(8)"), KErrNone);

  9414 	if (iTestResult != EPass)

  9415 		{

  9416 		INFO_PRINTF1(_L("File Sink EmptyBufferL(8) failed"));

  9417 		failure = ETrue;

  9418 		iTestResult = EPass;

  9419 		}

  9421 	// Create valid buffer 5.

  9422 	CMMFDescriptorBuffer* validBuffer5 = CMMFDescriptorBuffer::NewL(KTestWriteSize);

  9423 	CleanupStack::PushL(validBuffer5);

  9425 	// Set the length to write.

  9426 	validBuffer5->Data().SetLength(KTestWriteSize);

  9428 	User::LeaveIfError(bufferArray.Append(validBuffer5));

  9429 	DoFileTest(testStep5, _L("File sink EmptyBufferL(9)"), KErrNone);

  9430 	if (iTestResult != EPass)

  9431 		{

  9432 		INFO_PRINTF1(_L("File Sink EmptyBufferL(9) failed"));

  9433 		failure = ETrue;

  9434 		iTestResult = EPass;

  9435 		}

  9437 	// Test multiple write requests that do not get completed.

  9438 	TFileEmptyBuffer5TestStep testStep6(iSinkType, &bufferArray, dummySource, testFsSession, testFileName, dataPtr);

  9439 	testStep6.SetAsynchronousWrite(ETrue);

  9440 	testStep6.SetWriteLength(KTestWriteSize);

  9441 	testStep6.SetMaxRequestCount(3);

  9442 	DoFileTest(testStep6, _L("File sink EmptyBufferL(10)"), KErrNone);

  9443 	if (iTestResult != EPass)

  9444 		{

  9445 		INFO_PRINTF1(_L("File Sink EmptyBufferL(10) failed"));

  9446 		failure = ETrue;

  9447 		iTestResult = EPass;

  9448 		}

  9450 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9452 	dataPtr.SetLength(0);

  9453 	// Test multiple write requests, checking correct deletion of completed requests.

  9454 	sink = CreateFileSinkL(iSinkType, testFsSession, testFileName);

  9455 	CleanupDeletePushL(sink);

  9457 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  9458 	sink->SinkPrimeL();

  9460 	TFileEmptyBuffer6TestStep testStep7(sink, &bufferArray, dummySource, testFsSession, testFileName, dataPtr);

  9461 	testStep7.SetAsynchronousWrite(ETrue);

  9462 	testStep7.SetWriteLength(KTestWriteSize);

  9463 	DoTestStep(testStep7, _L("File sink EmptyBufferL(11)"), KErrNone, 4);

  9464 	if (iTestResult != EPass)

  9465 		{

  9466 		INFO_PRINTF1(_L("File Sink EmptyBufferL(11) failed"));

  9467 		failure = ETrue;

  9468 		iTestResult = EPass;

  9469 		}

  9471 	CleanupStack::PopAndDestroy(sink);

  9473 	CleanupStack::PopAndDestroy(5, &bufferArray); // validBuffer5, 4, 3, 2, bufferArray.

  9475 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9477 	dataPtr.SetLength(0);

  9478 	// Test zero length write.

  9479 	TFileEmptyBuffer2TestStep testStep8(iSinkType, zeroBuffer, dummySource, testFsSession, testFileName, dataPtr);

  9480 	testStep8.SetAsynchronousWrite(ETrue);

  9481 	DoFileTest(testStep8, _L("File sink EmptyBufferL(12)"), KErrNone);

  9482 	if (iTestResult != EPass)

  9483 		{

  9484 		INFO_PRINTF1(_L("File Sink EmptyBufferL(12) failed"));

  9485 		failure = ETrue;

  9486 		iTestResult = EPass;

  9487 		}

  9489 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9491 	CleanupStack::PopAndDestroy(6, dataDes); // dummySource, validBuffer, zeroBuffer, testFsSession, scheduler, dataDes.

  9493 	__MM_HEAP_MARKEND;

  9495 	return (failure ? EFail : EPass);

  9496 	}

  9498 /**

  9499  *

  9500  * CTestStep_MMF_SRSSNK_U_0112 constructor

  9501  *

  9502  * @xxxx

  9503  *

  9504  */

  9505 CTestStep_MMF_SRSSNK_U_0112::CTestStep_MMF_SRSSNK_U_0112()

  9506 : CTestStep_MMF_SRSSNK(EFalse)

  9507 	{

  9508 	// store the name of this test case

  9509 	// this is the name that is used by the script file

  9510 	// Each test step initialises it's own name

  9511 	iTestStepName = _L("MM-MMF-SRSSNK-U-0112");

  9512 	}

  9514 /**

  9515  *

  9516  * CTestStep_MMF_SRSSNK_U_0112 destructor

  9517  *

  9518  * @xxxx

  9519  *

  9520  */

  9521 CTestStep_MMF_SRSSNK_U_0112::~CTestStep_MMF_SRSSNK_U_0112()

  9522 	{

  9523 	}

  9525 /**

  9526  *

  9527  * CTestStep_MMF_SRSSNK_U_0112

  9528  *

  9529  * Functional test of file sink.

  9530  * BufferFilledL() panic test.

  9531  *

  9532  * @xxxx

  9533  */

  9534 TVerdict CTestStep_MMF_SRSSNK_U_0112::DoTestStepL()

  9535 	{

  9536 	__MM_HEAP_MARK;

  9538 	// This test fails if running a debug StdSourcesAndSinks dll.

  9539 	// So only perform the test on target.

  9541 	iTestResult = EFail;

  9543 	// Initialise config data.

  9544 	TMMFFileConfig configDes;

  9545 	configDes().iPath = KTest101FileName;

  9547 	// Create valid buffer.

  9548 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9549 	CleanupStack::PushL(validBuffer);

  9551 	// Create file sink.

  9552 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfFileSink, configDes);

  9553 	CleanupDeletePushL(sink);

  9555 	// Test BufferFilledL

  9556 	TRAPD(err, sink->BufferFilledL(validBuffer));

  9557 	if (err == KErrNone)

  9558 		{

  9559 		iTestResult = EPass;

  9560 		}

  9562 	CleanupStack::PopAndDestroy(sink);

  9564 	CleanupStack::PopAndDestroy(validBuffer);

  9566 	__MM_HEAP_MARKEND;

  9567 	return iTestResult;

  9568 	}

  9570 /**

  9571  *

  9572  * CTestStep_MMF_SRSSNK_FileWriteBuffer constructor

  9573  *

  9574  * @xxxx

  9575  *

  9576  */

  9577 CTestStep_MMF_SRSSNK_FileWriteBuffer::CTestStep_MMF_SRSSNK_FileWriteBuffer(TSinkType aSinkType)

  9578 	: iSinkType(aSinkType)

  9579 	{

  9580 	// store the name of this test case

  9581 	// this is the name that is used by the script file

  9582 	// Each test step initialises it's own name

  9583 	if (aSinkType == ESinkTypeFile)

  9584 		{

  9585 		iTestStepName = _L("MM-MMF-SRSSNK-U-0113");

  9586 		}

  9587 	else

  9588 		{

  9589 		iTestStepName = _L("MM-MMF-SRSSNK-U-0132");

  9590 		}

  9591 	}

  9593 /**

  9594  *

  9595  * CTestStep_MMF_SRSSNK_FileWriteBuffer destructor

  9596  *

  9597  * @xxxx

  9598  *

  9599  */

  9600 CTestStep_MMF_SRSSNK_FileWriteBuffer::~CTestStep_MMF_SRSSNK_FileWriteBuffer()

  9601 	{

  9602 	}

  9604 /**

  9605  *

  9606  * CTestStep_MMF_SRSSNK_FileWriteBuffer

  9607  *

  9608  * Functional test of descriptor sink.

  9609  * WriteBufferL() test.

  9610  *

  9611  * @xxxx

  9612  */

  9613 TVerdict CTestStep_MMF_SRSSNK_FileWriteBuffer::DoTestStepL()

  9614 	{

  9615 	__MM_HEAP_MARK;

  9617 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  9618 	TPtr8 dataPtr(dataDes->Des());

  9620 	// Initialise thread active scheduler.

  9621 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  9622 	CleanupStack::PushL(scheduler);

  9623 	CActiveScheduler::Install(scheduler);

  9625 	// Set the filename and create a file session.

  9626 	TFileName testFileName(KTest103FileName);

  9628 	RFs testFsSession;

  9629 	User::LeaveIfError(testFsSession.Connect());

  9630 	CleanupClosePushL(testFsSession);

  9632 	// Initialise config data.

  9633 	TMMFFileConfig configFile;

  9634 	configFile().iPath = testFileName;

  9636 	// Create zero length buffer.

  9637 	CMMFDescriptorBuffer* zeroBuffer = CMMFDescriptorBuffer::NewL(0);

  9638 	CleanupStack::PushL(zeroBuffer);

  9640 	// Create valid buffer.

  9641 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9642 	CleanupStack::PushL(validBuffer);

  9644 	// Set it's length

  9645 	validBuffer->Data().SetLength(KTestWriteSize);

  9647 	// Create dummy source.

  9648 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

  9649 	CleanupStack::PushL(dummySource);

  9651 	// Create sink.

  9652 	CMMFClip* sink = static_cast<CMMFClip*> (CreateFileSinkL(iSinkType, testFsSession, testFileName));

  9653 	CleanupStack::PushL(sink);

  9655 	// check that Size() can be called before SinkPrimeL()

  9656 	TInt size = sink->Size();

  9658 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  9660 	// Create a test (invalid) buffer.

  9661 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

  9662 	CleanupStack::PushL(testBuffer);

  9664 	// Test WriteBufferL (these tests should fail)

  9665 	TFileWriteBufferTestStep testStep(sink, testBuffer, 0, dummySource, testFsSession, testFileName, dataPtr);

  9666 	DoFileTest(testStep, _L("File sink WriteBufferL(1)"), KErrNotSupported);

  9668 	TFileWriteBuffer2TestStep testStep2(sink, testBuffer, 0, dummySource, testFsSession, testFileName, dataPtr);

  9669 	DoFileTest(testStep2, _L("File sink WriteBufferL(2)"), KErrNotSupported);

  9671 	TFileWriteBuffer3TestStep testStep3(sink, testBuffer, 0, testFsSession, testFileName, dataPtr);

  9672 	DoFileTest(testStep3, _L("File sink WriteBufferL(3)"), KErrNotSupported);

  9673 	CleanupStack::PopAndDestroy(testBuffer);

  9675 	// Test writing to the beginning, middle and end.

  9676 	TFileWriteBufferTestStep testStep4(sink, validBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9677 	DoFileTestWithoutAllocFail(testStep4, _L("File sink WriteBufferL(4)"), KErrNone, 2);

  9678 	CleanupStack::PopAndDestroy(sink);

  9680 	TFileWriteBuffer4TestStep testStep5(iSinkType, testFileName, validBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9681 	DoFileTest(testStep5, _L("File sink WriteBufferL(5)"), KErrNone);

  9683 	testStep5.SetPosition(1);

  9684 	DoFileTest(testStep5, _L("File sink WriteBufferL(6)"), KErrNone);

  9686 	testStep5.SetPosition(KTestDataSize/2);

  9687 	DoFileTest(testStep5, _L("File sink WriteBufferL(7)"), KErrNone);

  9689 	testStep5.SetPosition(KTestDataSize/2 + 1);

  9690 	DoFileTest(testStep5, _L("File sink WriteBufferL(8)"), KErrNone);

  9692 	testStep5.SetPosition(KTestDataSize - 10);

  9693 	testStep5.SetWriteLength(10);

  9694 	DoFileTest(testStep5, _L("File sink WriteBufferL(9)"), KErrNone);

  9696 	testStep5.SetPosition(KTestDataSize);

  9697 	testStep5.SetWriteLength(0);

  9698 	DoFileTest(testStep5, _L("File sink WriteBufferL(10)"), KErrNone);

  9700 	testStep5.SetPosition(KTestDataSize + 2);

  9701 	testStep5.SetWriteLength(0);

  9702 	DoFileTest(testStep5, _L("File sink WriteBufferL(11)"), KErrNone);

  9704 	// Attempt to write more data than is in the buffer.

  9705 	TFileWriteBuffer5TestStep testStep6(iSinkType, testFileName, validBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9706 	testStep6.SetPosition(KTestDataSize);

  9707 	testStep6.SetWriteLength(KTestOverWriteSize);

  9708 	DoFileTest(testStep6, _L("File sink WriteBufferL(12)"), KErrNone);

  9710 	// Attempt to write a zero length buffer.

  9711 	TFileWriteBuffer4TestStep testStep7(iSinkType, testFileName, zeroBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9712 	testStep7.SetWriteLength(0);

  9713 	DoFileTest(testStep7, _L("File sink WriteBufferL(13)"), KErrNone);

  9716 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9718 	// Repeat writes without supplying the length to write.

  9719 	dataPtr.SetLength(0);

  9721 	sink = static_cast<CMMFClip*> (CreateFileSinkL(iSinkType, testFsSession, testFileName));

  9722 	CleanupStack::PushL(sink);

  9723 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  9725 	TFileWriteBuffer2TestStep testStep8(sink, validBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9726 	DoFileTestWithoutAllocFail(testStep8, _L("File sink WriteBufferL(14)"), KErrNone, 2);

  9727 	CleanupStack::PopAndDestroy(sink);

  9729 	TFileWriteBuffer6TestStep testStep9(iSinkType, testFileName, validBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9730 	DoFileTest(testStep9, _L("File sink WriteBufferL(15)"), KErrNone);

  9732 	testStep9.SetPosition(1);

  9733 	DoFileTest(testStep9, _L("File sink WriteBufferL(16)"), KErrNone);

  9735 	testStep9.SetPosition(KTestDataSize/2);

  9736 	DoFileTest(testStep9, _L("File sink WriteBufferL(17)"), KErrNone);

  9738 	testStep9.SetPosition(KTestDataSize/2 + 1);

  9739 	DoFileTest(testStep9, _L("File sink WriteBufferL(18)"), KErrNone);

  9741 	testStep9.SetPosition(KTestDataSize - 10);

  9742 	testStep9.SetWriteLength(10);

  9743 	DoFileTest(testStep9, _L("File sink WriteBufferL(19)"), KErrNone);

  9745 	testStep9.SetPosition(KTestDataSize);

  9746 	testStep9.SetWriteLength(0);

  9747 	DoFileTest(testStep9, _L("File sink WriteBufferL(20)"), KErrNone);

  9749 	testStep9.SetPosition(KTestDataSize + 2);

  9750 	testStep9.SetWriteLength(0);

  9751 	DoFileTest(testStep9, _L("File sink WriteBufferL(21)"), KErrNone);

  9753 	// Attempt to write a zero length buffer.

  9754 	TFileWriteBuffer6TestStep testStep10(iSinkType, testFileName, zeroBuffer, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9755 	testStep10.SetWriteLength(0);

  9756 	DoFileTest(testStep10, _L("File sink WriteBufferL(22)"), KErrNone);

  9758 	// Delete the test file.

  9759 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9761 	// Repeat writes without supplying the length, or a source.

  9762 	dataPtr.SetLength(0);

  9764 	sink = static_cast<CMMFClip*> (CreateFileSinkL(iSinkType, testFsSession, testFileName));

  9765 	CleanupStack::PushL(sink);

  9766 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

  9768 	TFileWriteBuffer3TestStep testStep11(sink, validBuffer, 0, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9769 	DoFileTest(testStep11, _L("File sink WriteBufferL(23)"), KErrNone);

  9770 	CleanupStack::PopAndDestroy(sink);

  9772 	TFileWriteBuffer7TestStep testStep12(iSinkType, testFileName, validBuffer, 0, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9773 	DoFileTest(testStep12, _L("File sink WriteBufferL(24)"), KErrNone);

  9775 	testStep12.SetPosition(1);

  9776 	DoFileTest(testStep12, _L("File sink WriteBufferL(25)"), KErrNone);

  9778 	testStep12.SetPosition(KTestDataSize/2);

  9779 	DoFileTest(testStep12, _L("File sink WriteBufferL(26)"), KErrNone);

  9781 	testStep12.SetPosition(KTestDataSize/2 + 1);

  9782 	DoFileTest(testStep12, _L("File sink WriteBufferL(27)"), KErrNone);

  9784 	testStep12.SetPosition(KTestDataSize - 10);

  9785 	testStep12.SetWriteLength(10);

  9786 	DoFileTest(testStep12, _L("File sink WriteBufferL(28)"), KErrNone);

  9788 	testStep12.SetPosition(KTestDataSize);

  9789 	testStep12.SetWriteLength(0);

  9790 	DoFileTest(testStep12, _L("File sink WriteBufferL(29)"), KErrNone);

  9792 	testStep12.SetPosition(KTestDataSize + 2);

  9793 	testStep12.SetWriteLength(0);

  9794 	DoFileTest(testStep12, _L("File sink WriteBufferL(30)"), KErrNone);

  9796 	// Attempt to write a zero length buffer.

  9797 	TFileWriteBuffer7TestStep testStep13(iSinkType, testFileName, zeroBuffer, 0, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9798 	testStep13.SetWriteLength(0);

  9799 	DoFileTest(testStep13, _L("File sink WriteBufferL(31)"), KErrNone);

  9801 	// Delete the test file.

  9802 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9804 	// Test multiple write requests.

  9805 	dataPtr.SetLength(0);

  9806 	RPointerArray<CMMFBuffer> bufferArray;

  9807 	CleanupClosePushL(bufferArray);

  9809 	User::LeaveIfError(bufferArray.Append(validBuffer));

  9810 	TFileWriteBuffer8TestStep testStep14(iSinkType, testFileName, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9811 	TFileWriteBuffer9TestStep testStep15(iSinkType, testFileName, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9812 	DoFileTest(testStep14, _L("File sink WriteBufferL(32)"), KErrNone);

  9813 	DoFileTest(testStep15, _L("File sink WriteBufferL(33)"), KErrNone);

  9815 	CMMFDescriptorBuffer* validBuffer2 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9816 	CleanupStack::PushL(validBuffer2);

  9818 	validBuffer2->Data().SetLength(KTestWriteSize);

  9819 	User::LeaveIfError(bufferArray.Append(validBuffer2));

  9820 	DoFileTest(testStep14, _L("File sink WriteBufferL(34)"), KErrNone);

  9821 	DoFileTest(testStep15, _L("File sink WriteBufferL(35)"), KErrNone);

  9823 	CMMFDescriptorBuffer* validBuffer3 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9824 	CleanupStack::PushL(validBuffer3);

  9826 	validBuffer3->Data().SetLength(KTestWriteSize);

  9827 	User::LeaveIfError(bufferArray.Append(validBuffer3));

  9828 	DoFileTest(testStep14, _L("File sink WriteBufferL(36)"), KErrNone);

  9829 	DoFileTest(testStep15, _L("File sink WriteBufferL(37)"), KErrNone);

  9831 	CMMFDescriptorBuffer* validBuffer4 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9832 	CleanupStack::PushL(validBuffer4);

  9834 	validBuffer4->Data().SetLength(KTestWriteSize);

  9835 	User::LeaveIfError(bufferArray.Append(validBuffer4));

  9836 	DoFileTest(testStep14, _L("File sink WriteBufferL(38)"), KErrNone);

  9837 	DoFileTest(testStep15, _L("File sink WriteBufferL(39)"), KErrNone);

  9839 	CMMFDescriptorBuffer* validBuffer5 = CMMFDescriptorBuffer::NewL(KTestBufferSize);

  9840 	CleanupStack::PushL(validBuffer5);

  9842 	validBuffer5->Data().SetLength(KTestWriteSize);

  9843 	User::LeaveIfError(bufferArray.Append(validBuffer5));

  9844 	DoFileTest(testStep14, _L("File sink WriteBufferL(40)"), KErrNone);

  9845 	DoFileTest(testStep15, _L("File sink WriteBufferL(41)"), KErrNone);

  9847 	// Test multiple write requests that do not get completed.

  9848 	TFileWriteBuffer10TestStep testStep16(iSinkType, testFileName, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9849 	DoFileTest(testStep16, _L("File sink WriteBufferL(42)"), KErrNone);

  9851 	TFileWriteBuffer11TestStep testStep17(iSinkType, testFileName, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9852 	DoFileTest(testStep17, _L("File sink WriteBufferL(43)"), KErrNone);

  9854 	// Test multiple write requests, checking correct deletion of completed requests.

  9855 	CMMFClip* clip = static_cast<CMMFClip*> (CreateFileSinkL(iSinkType, testFsSession, testFileName));

  9856 	CleanupDeletePushL(clip);

  9858 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  9859 	TFileWriteBuffer12TestStep testStep18(clip, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9860 	DoTestStep(testStep18, _L("File sink WriteBufferL(44)"), KErrNone, 4);

  9862 	CleanupStack::PopAndDestroy(clip);

  9864 	clip = static_cast<CMMFClip*> (CreateFileSinkL(iSinkType, testFsSession, testFileName));

  9865 	CleanupStack::PushL(clip);

  9867 	User::LeaveIfError(clip->SinkThreadLogon(*dummySource));

  9868 	TFileWriteBuffer13TestStep testStep19(clip, &bufferArray, 0, dummySource, testFsSession, testFileName, dataPtr, KTestWriteSize);

  9869 	DoTestStep(testStep19, _L("File sink WriteBufferL(45)"), KErrNone, 4);

  9871 	CleanupStack::PopAndDestroy(clip);

  9873 	// Delete the test file.

  9874 	DeleteFileSinkL(iSinkType, testFsSession, testFileName);

  9876 	CleanupStack::PopAndDestroy(11, dataDes); // validBuffer5, 4, 3, 2, bufferArray, dummySource, validBuffer, zeroBuffer, testFsSession, scheduler, dataDes

  9878 	__MM_HEAP_MARKEND;

  9879 	return iTestResult;

  9880 	}

  9882 /**

  9883  *

  9884  * CTestStep_MMF_SRSSNK_U_0114 constructor

  9885  *

  9886  * @xxxx

  9887  *

  9888  */

  9889 CTestStep_MMF_SRSSNK_U_0114::CTestStep_MMF_SRSSNK_U_0114()

  9890 	{

  9891 	// store the name of this test case

  9892 	// this is the name that is used by the script file

  9893 	// Each test step initialises it's own name

  9894 	iTestStepName = _L("MM-MMF-SRSSNK-U-0114");

  9895 	}

  9897 /**

  9898  *

  9899  * CTestStep_MMF_SRSSNK_U_0114 destructor

  9900  *

  9901  * @xxxx

  9902  *

  9903  */

  9904 CTestStep_MMF_SRSSNK_U_0114::~CTestStep_MMF_SRSSNK_U_0114()

  9905 	{

  9906 	}

  9908 /**

  9909  *

  9910  * CTestStep_MMF_SRSSNK_U_0114

  9911  *

  9912  * Functional test of file sink.

  9913  * SinkCustomCommand() test.

  9914  *

  9915  * @xxxx

  9916  */

  9917 TVerdict CTestStep_MMF_SRSSNK_U_0114::DoTestStepL()

  9918 	{

  9919 	__MM_HEAP_MARK;

  9921 	// Initialise config data.

  9922 	TMMFFileConfig configDes;

  9923 	configDes().iPath = KTest101FileName;

  9925 	TUid testControllerUid = { KMmfTestControllerUid };

  9926 	RMMFController dummyController;

  9927 	TMMFPrioritySettings prioritySettings;

  9928 	TMMFMessageDestinationPckg destination;

  9929 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

  9930 	CleanupClosePushL(dummyController);

  9932 	TBuf8<1> dummyArgs;

  9933 	User::LeaveIfError(dummyController.AddDataSink(KUidMmfFileSink, configDes));

  9934 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSink, dummyArgs, dummyArgs);

  9935 	if (err != KErrNotSupported)

  9936 		{

  9937 		INFO_PRINTF2(_L("File sink SinkCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

  9938 		iTestResult = EFail;

  9939 		}

  9941 	CleanupStack::PopAndDestroy(&dummyController);

  9943 	__MM_HEAP_MARKEND;

  9944 	return iTestResult;

  9945 	}

  9947 /**

  9948  *

  9949  * CTestStep_MMF_SRSSNK_U_0115 constructor

  9950  *

  9951  * @xxxx

  9952  *

  9953  */

  9954 CTestStep_MMF_SRSSNK_U_0115::CTestStep_MMF_SRSSNK_U_0115()

  9955 	{

  9956 	// store the name of this test case

  9957 	// this is the name that is used by the script file

  9958 	// Each test step initialises it's own name

  9959 	iTestStepName = _L("MM-MMF-SRSSNK-U-0115");

  9960 	}

  9962 /**

  9963  *

  9964  * CTestStep_MMF_SRSSNK_U_0115 destructor

  9965  *

  9966  * @xxxx

  9967  *

  9968  */

  9969 CTestStep_MMF_SRSSNK_U_0115::~CTestStep_MMF_SRSSNK_U_0115()

  9970 	{

  9971 	}

  9973 /**

  9974  *

  9975  * CTestStep_MMF_SRSSNK_U_0115

  9976  *

  9977  * CMMFFile

  9978  * Request size / SetLastBuffer test.

  9979  *

  9980  * @xxxx

  9981  */

  9982 TVerdict CTestStep_MMF_SRSSNK_U_0115::DoTestStepL()

  9983 	{

  9984 	__MM_HEAP_MARK;

  9986 	// Create source buffer.

  9987 	HBufC8* dataDes = HBufC8::NewLC(KTestDataSize);

  9988 	TPtr8 dataPtr(dataDes->Des());

  9990 	// Initialise thread active scheduler.

  9991 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

  9992 	CleanupStack::PushL(scheduler);

  9993 	CActiveScheduler::Install(scheduler);

  9995 	// Initialise config data.

  9996 	TMMFFileConfig configDes;

  9997 	configDes().iPath = KTest101FileName;

  9999 	// Read the data from the file.

 10000 	RFs testFsSession;

 10001 	User::LeaveIfError(testFsSession.Connect()) ;

 10002 	CleanupClosePushL(testFsSession);

 10004 	RFile testFile;

 10005 	User::LeaveIfError(testFile.Open(testFsSession, configDes().iPath, EFileShareReadersOnly));

 10006 	CleanupClosePushL(testFile);

 10008 	User::LeaveIfError(testFile.Read(dataPtr));

 10009 	CleanupStack::PopAndDestroy(2); // testFile, testFsSession

 10011 	// Create dummy sink.

 10012 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10013 	CleanupStack::PushL(dummySink);

 10015 	// Test fill last buffer

 10016 	TFillLastBufferTestStep testStep(KUidMmfFileSource, configDes, dummySink, dataPtr);

 10017 	testStep.SetAsynchronousRead(ETrue);

 10018 	DoFileTest(testStep, _L("File source: Fill last buffer"), KErrNone);

 10020 	// Create a source.

 10021 	CMMFClip* source = STATIC_CAST(CMMFClip*, MDataSource::NewSourceL(KUidMmfFileSource, configDes));

 10022 	CleanupDeletePushL(source);

 10023 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10024 	source->SourcePrimeL();

 10026 	// Test read last buffer (API version 1)

 10027 	TReadLastBufferTestStep testStep2(source, dummySink, dataPtr);

 10028 	testStep2.SetAsynchronousRead(ETrue);

 10029 	DoFileTestWithoutAllocFail(testStep2, _L("File source: Read last buffer"), KErrNone, 2);

 10031 	TReadLastBuffer2TestStep testStep3(source, dummySink, dataPtr);

 10032 	testStep3.SetAsynchronousRead(ETrue);

 10033 	DoFileTestWithoutAllocFail(testStep3, _L("File source: Read last buffer"), KErrNone, 2);

 10035 	TReadLastBuffer3TestStep testStep4(source, dataPtr);

 10036 	testStep4.SetAsynchronousRead(ETrue);

 10037 	DoFileTestWithoutAllocFail(testStep4, _L("File source: Read last buffer"), KErrNone, 2);

 10039 	CleanupStack::PopAndDestroy(source);

 10041 	CleanupStack::PopAndDestroy(3, dataDes); // dummySink, scheduler, dataDes

 10043 	__MM_HEAP_MARKEND;

 10044 	return iTestResult;

 10045 	}

 10049 /**

 10050  *

 10051  * CTestStep_MMF_SRSSNK_FileEvaluateIntent constructor

 10052  *

 10053  * @xxxx

 10054  *

 10055  */

 10056 CTestStep_MMF_SRSSNK_FileEvaluateIntent::CTestStep_MMF_SRSSNK_FileEvaluateIntent(TSourceType aSourceType)

 10057 	: iSourceType(aSourceType)

 10058 	{

 10059 	if (aSourceType == ESourceTypeFile)

 10060 		{

 10061 		iTestStepName = _L("MM-MMF-SRSSNK-U-0116");

 10062 		iSinkType = ESinkTypeFile;

 10063 		}

 10064 	else

 10065 		{

 10066 		iTestStepName = _L("MM-MMF-SRSSNK-U-0140");

 10067 		iSinkType = ESinkTypeFileHandle;

 10068 		}

 10069 	}

 10071 /**

 10072  *

 10073  * CTestStep_MMF_SRSSNK_FileEvaluateIntent destructor

 10074  *

 10075  * @xxxx

 10076  *

 10077  */

 10078 CTestStep_MMF_SRSSNK_FileEvaluateIntent::~CTestStep_MMF_SRSSNK_FileEvaluateIntent()

 10079 	{

 10080 	}

 10082 /**

 10083  *

 10084  * CTestStep_MMF_SRSSNK_FileEvaluateIntent

 10085  *

 10086  * CMMFFile

 10087  * Evaluate Intent

 10088  *

 10089  * @xxxx

 10090  */

 10091 TVerdict CTestStep_MMF_SRSSNK_FileEvaluateIntent::DoTestStepL()

 10092 	{

 10093 	__MM_HEAP_MARK;

 10095 	// Initialise thread active scheduler.

 10096 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10097 	CleanupStack::PushL(scheduler);

 10098 	CActiveScheduler::Install(scheduler);

 10100 	TFileName testFileName(KTest101FileName);

 10101 	RFs testFsSession;

 10102 	User::LeaveIfError(testFsSession.Connect());

 10103 	CleanupClosePushL(testFsSession);

 10105 	// Create dummy source

 10106 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 10107 	CleanupStack::PushL(dummySource);

 10110 	// Create dummy sink.

 10111 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10112 	CleanupStack::PushL(dummySink);

 10115 	// Create a source.

 10116 	CMMFClip* source = static_cast<CMMFClip*>(CreateFileSourceL(iSourceType, testFsSession, testFileName));

 10117 	CleanupDeletePushL(source);

 10118 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10119 	source->SourcePrimeL();

 10121 	// we know it is a file source since we have just created it

 10122 	CMMFFile* file = static_cast<CMMFFile*>(source);

 10124 	// file open, for unprotected files this should always return KErrNone

 10125 	TInt err = file->EvaluateIntent(EPeek);

 10126 	if (err != KErrNone)

 10127 		iTestResult = EFail;

 10129 	source->SourceStopL();

 10131 	// file closed

 10132 	err = file->EvaluateIntent(EPeek);

 10133 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10134 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10135 		{

 10136 		iTestResult = EFail;

 10137 		}

 10139 	CleanupStack::PopAndDestroy(source);

 10141 	// Create a sink.

 10142 	CMMFClip* sink = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, testFsSession, testFileName));

 10143 	CleanupDeletePushL(sink);

 10144 	User::LeaveIfError(sink->SourceThreadLogon(*dummySource));

 10145 	sink->SinkPrimeL();

 10147 	// we know it is a file sink since we have just created it

 10148 	file = static_cast<CMMFFile*>(sink);

 10150 	// file open, for unprotected files this should always return KErrNone

 10151 	err = file->EvaluateIntent(EPeek);

 10152 	if (err != KErrNone)

 10153 		iTestResult = EFail;

 10155 	sink->SinkStopL();

 10157 	// file closed

 10158 	err = file->EvaluateIntent(EPeek);

 10159 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10160 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10161 		{

 10162 		iTestResult = EFail;

 10163 		}

 10165 	CleanupStack::PopAndDestroy(sink);

 10168 	CleanupStack::PopAndDestroy(4, scheduler); // dummySink, dummySource, testFsSession, scheduler

 10170 	__MM_HEAP_MARKEND;

 10171 	return iTestResult;

 10172 	}

 10176 /**

 10177  *

 10178  * CTestStep_MMF_SRSSNK_FileExecuteIntent constructor

 10179  *

 10180  * @xxxx

 10181  *

 10182  */

 10183 CTestStep_MMF_SRSSNK_FileExecuteIntent::CTestStep_MMF_SRSSNK_FileExecuteIntent(TSourceType aSourceType)

 10184 	: iSourceType(aSourceType)

 10185 	{

 10186 	if (aSourceType == ESourceTypeFile)

 10187 		{

 10188 		iTestStepName = _L("MM-MMF-SRSSNK-U-0117");

 10189 		iSinkType = ESinkTypeFile;

 10190 		}

 10191 	else

 10192 		{

 10193 		iTestStepName = _L("MM-MMF-SRSSNK-U-0141");

 10194 		iSinkType = ESinkTypeFileHandle;

 10195 		}

 10197 	}

 10199 /**

 10200  *

 10201  * CTestStep_MMF_SRSSNK_FileExecuteIntent destructor

 10202  *

 10203  * @xxxx

 10204  *

 10205  */

 10206 CTestStep_MMF_SRSSNK_FileExecuteIntent::~CTestStep_MMF_SRSSNK_FileExecuteIntent()

 10207 	{

 10208 	}

 10210 /**

 10211  *

 10212  * CTestStep_MMF_SRSSNK_FileExecuteIntent

 10213  *

 10214  * CMMFFile

 10215  * Execute Intent test

 10216  *

 10217  * @xxxx

 10218  */

 10219 TVerdict CTestStep_MMF_SRSSNK_FileExecuteIntent::DoTestStepL()

 10220 	{

 10221 	__MM_HEAP_MARK;

 10223 	// Initialise thread active scheduler.

 10224 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10225 	CleanupStack::PushL(scheduler);

 10226 	CActiveScheduler::Install(scheduler);

 10228 	TFileName testFileName(KTest101FileName);

 10229 	RFs testFsSession;

 10230 	User::LeaveIfError(testFsSession.Connect());

 10231 	CleanupClosePushL(testFsSession);

 10233 	// Create dummy source

 10234 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 10235 	CleanupStack::PushL(dummySource);

 10238 	// Create dummy sink.

 10239 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10240 	CleanupStack::PushL(dummySink);

 10243 	// Create a source.

 10244 	CMMFClip* source = static_cast<CMMFClip*>(CreateFileSourceL(iSourceType, testFsSession, testFileName));

 10245 	CleanupDeletePushL(source);

 10246 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10247 	source->SourcePrimeL();

 10249 	// we know it is a file source since we have just created it

 10250 	CMMFFile* file = static_cast<CMMFFile*>(source);

 10252 	// file open, for unprotected files this should always return KErrNone

 10253 	TInt err = file->ExecuteIntent(EPeek);

 10254 	if (err != KErrNone)

 10255 		{

 10256 		iTestResult = EFail;

 10257 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrNone, err);

 10258 		}

 10260 	source->SourceStopL();

 10262 	// file closed

 10263 	err = file->ExecuteIntent(EPeek);

 10264 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10265 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10266 		{

 10267 		iTestResult = EFail;

 10268 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), iSinkType == ESinkTypeFile ? KErrNotReady : KErrNone, err);

 10269 		}

 10271 	CleanupStack::PopAndDestroy(source);

 10273 	// Create a sink.

 10274 	CMMFClip* sink = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, testFsSession, testFileName));

 10275 	CleanupDeletePushL(sink);

 10276 	User::LeaveIfError(sink->SourceThreadLogon(*dummySource));

 10277 	sink->SinkPrimeL();

 10279 	// we know it is a file sink since we have just created it

 10280 	file = static_cast<CMMFFile*>(sink);

 10282 	// file open, for unprotected files this should always return KErrNone

 10283 	err = file->ExecuteIntent(EPeek);

 10284 	if (err != KErrNone)

 10285 		{

 10286 		iTestResult = EFail;

 10287 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrNone, err);

 10288 		}

 10290 	sink->SinkStopL();

 10292 	// file closed

 10293 	err = file->ExecuteIntent(EPeek);

 10294 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10295 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10296 		{

 10297 		iTestResult = EFail;

 10298 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), iSinkType == ESinkTypeFile ? KErrNotReady : KErrNone, err);

 10299 		}

 10301 	CleanupStack::PopAndDestroy(sink);

 10304 	CleanupStack::PopAndDestroy(4, scheduler); // dummySink, dummySource, testFsSession, scheduler

 10306 	__MM_HEAP_MARKEND;

 10307 	return iTestResult;

 10308 	}

 10311 /**

 10312  *

 10313  * CTestStep_MMF_SRSSNK_FileIsProtected constructor

 10314  *

 10315  * IsProtected Test

 10316  * @xxxx

 10317  *

 10318  */

 10319 CTestStep_MMF_SRSSNK_FileIsProtected::CTestStep_MMF_SRSSNK_FileIsProtected(TSourceType aSourceType)

 10320 	: iSourceType(aSourceType)

 10321 	{

 10322 	if (aSourceType == ESourceTypeFile)

 10323 		{

 10324 		iTestStepName = _L("MM-MMF-SRSSNK-U-0118");

 10325 		iSinkType = ESinkTypeFile;

 10326 		}

 10327 	else

 10328 		{

 10329 		iTestStepName = _L("MM-MMF-SRSSNK-U-0142");

 10330 		iSinkType = ESinkTypeFileHandle;

 10331 		}

 10332 	}

 10334 /**

 10335  *

 10336  * CTestStep_MMF_SRSSNK_FileIsProtected destructor

 10337  *

 10338  * @xxxx

 10339  *

 10340  */

 10341 CTestStep_MMF_SRSSNK_FileIsProtected::~CTestStep_MMF_SRSSNK_FileIsProtected()

 10342 	{

 10343 	}

 10345 /**

 10346  *

 10347  * CTestStep_MMF_SRSSNK_FileIsProtected

 10348  *

 10349  * CMMFFile

 10350  * Execute Intent test

 10351  *

 10352  * @xxxx

 10353  */

 10354 TVerdict CTestStep_MMF_SRSSNK_FileIsProtected::DoTestStepL()

 10355 	{

 10356 	__MM_HEAP_MARK;

 10358 	// Initialise thread active scheduler.

 10359 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10360 	CleanupStack::PushL(scheduler);

 10361 	CActiveScheduler::Install(scheduler);

 10363 	TFileName testFileName(KTest101FileName);

 10364 	RFs testFsSession;

 10365 	User::LeaveIfError(testFsSession.Connect());

 10366 	CleanupClosePushL(testFsSession);

 10368 	// Create dummy source

 10369 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 10370 	CleanupStack::PushL(dummySource);

 10373 	// Create dummy sink.

 10374 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10375 	CleanupStack::PushL(dummySink);

 10378 	// Create a source.

 10379 	CMMFClip* source = static_cast<CMMFClip*>(CreateFileSourceL(iSourceType, testFsSession, testFileName));

 10380 	CleanupDeletePushL(source);

 10381 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10382 	source->SourcePrimeL();

 10384 	// we know it is a file source since we have just created it

 10385 	CMMFFile* file = static_cast<CMMFFile*>(source);

 10387 	TBool isProtected = EFalse;

 10388 	TInt err = KErrNone;

 10389 	// file open, for unprotected files this should always be false

 10390 	TRAP(err, isProtected = file->IsProtectedL());

 10391 	if (err != KErrNone)

 10392 		{

 10393 		iTestResult = EFail;

 10394 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrNone, err);

 10395 		}

 10396 	else if (isProtected)

 10397 		{

 10398 		iTestResult = EFail;

 10399 		INFO_PRINTF1(_L("Failure, expected unprotected file"));

 10400 		}

 10402 	source->SourceStopL();

 10404 	// file closed, should leave KErrNotReady

 10405 	TRAP(err, isProtected = file->IsProtectedL());

 10406 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10407 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10408 		{

 10409 		iTestResult = EFail;

 10410 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), iSinkType == ESinkTypeFile ? KErrNotReady : KErrNone, err);

 10411 		}

 10413 	CleanupStack::PopAndDestroy(source);

 10415 	// Create a sink.

 10416 	CMMFClip* sink = static_cast<CMMFClip*>(CreateFileSinkL(iSinkType, testFsSession, testFileName));

 10417 	CleanupDeletePushL(sink);

 10418 	User::LeaveIfError(sink->SourceThreadLogon(*dummySource));

 10419 	sink->SinkPrimeL();

 10421 	// we know it is a file sink since we have just created it

 10422 	file = static_cast<CMMFFile*>(sink);

 10424 	// file open, for unprotected files this should always return EFalse

 10425 	TRAP(err, isProtected = file->IsProtectedL());

 10426 	if (err != KErrNone)

 10427 		{

 10428 		iTestResult = EFail;

 10429 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrNone, err);

 10430 		}

 10431 	else if (isProtected)

 10432 		{

 10433 		iTestResult = EFail;

 10434 		INFO_PRINTF1(_L("Failure, expected unprotected file"));

 10435 		}

 10437 	sink->SinkStopL();

 10439 	// file closed, should leave KErrNotReady

 10440 	TRAP(err, isProtected = file->IsProtectedL());

 10441 	if (((iSinkType == ESinkTypeFile) && (err != KErrNotReady)) ||

 10442 		((iSinkType == ESinkTypeFileHandle) && (err != KErrNone)))

 10443 		{

 10444 		iTestResult = EFail;

 10445 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), iSinkType == ESinkTypeFile ? KErrNotReady : KErrNone, err);

 10446 		}

 10448 	CleanupStack::PopAndDestroy(sink);

 10451 	CleanupStack::PopAndDestroy(4, scheduler); // dummySink, dummySource, testFsSession, scheduler

 10453 	__MM_HEAP_MARKEND;

 10454 	return iTestResult;

 10455 	}

 10457 /**

 10458  *

 10459  * CTestStep_MMF_SRSSNK_U_0119 constructor

 10460  *

 10461  * @xxxx

 10462  *

 10463  */

 10464 CTestStep_MMF_SRSSNK_U_0119::CTestStep_MMF_SRSSNK_U_0119()

 10465 	{

 10466 	iTestStepName = _L("MM-MMF-SRSSNK-U-0119");

 10467 	}

 10469 /**

 10470  *

 10471  * CTestStep_MMF_SRSSNK_U_0119 destructor

 10472  *

 10473  * @xxxx

 10474  *

 10475  */

 10476 CTestStep_MMF_SRSSNK_U_0119::~CTestStep_MMF_SRSSNK_U_0119()

 10477 	{

 10478 	}

 10480 /**

 10481  *

 10482  * CTestStep_MMF_SRSSNK_U_0119

 10483  *

 10484  * CMMFFile

 10485  * Test file access denied

 10486  *

 10487  * @xxxx

 10488  */

 10489 TVerdict CTestStep_MMF_SRSSNK_U_0119::DoTestStepL()

 10490 	{

 10491 	__MM_HEAP_MARK;

 10493 	iTestResult = EPass;

 10494 	// Initialise thread active scheduler.

 10495 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10496 	CleanupStack::PushL(scheduler);

 10497 	CActiveScheduler::Install(scheduler);

 10499 	// Initialise config data.

 10500 	TMMFFileConfig configDes;

 10501 	configDes().iPath = KTest101FileName;

 10503 	// lock the file by opening it for writing for the duration of this test

 10504 	RFs fs;

 10505 	User::LeaveIfError(fs.Connect());

 10506 	CleanupClosePushL(fs);

 10508 	RFile file;

 10509 	User::LeaveIfError(file.Open(fs,KTest101FileName, EFileWrite));

 10510 	CleanupClosePushL(file);

 10512 	// Create dummy source

 10513 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 10514 	CleanupStack::PushL(dummySource);

 10517 	// Create dummy sink.

 10518 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10519 	CleanupStack::PushL(dummySink);

 10522 	// Create a source.

 10523 	CMMFClip* source = static_cast<CMMFClip*>(MDataSource::NewSourceL(KUidMmfFileSource, configDes));

 10524 	CleanupDeletePushL(source);

 10525 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10526 	TRAPD(err, source->SourcePrimeL());

 10527 	if (err != KErrInUse)

 10528 		{

 10529 		iTestResult = EFail;

 10530 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrInUse, err);

 10531 		}

 10534 	CleanupStack::PopAndDestroy(source);

 10536 	// Create a sink.

 10537 	CMMFClip* sink = static_cast<CMMFClip*>(MDataSink::NewSinkL(KUidMmfFileSink, configDes));

 10538 	CleanupDeletePushL(sink);

 10539 	User::LeaveIfError(sink->SourceThreadLogon(*dummySource));

 10541 	TRAP(err, sink->SinkPrimeL());

 10542 	if (err != KErrInUse)

 10544 		{

 10545 		iTestResult = EFail;

 10546 		INFO_PRINTF3(_L("Failure, expected error %d, received error %d"), KErrInUse, err);

 10547 		}

 10550 	CleanupStack::PopAndDestroy(sink);

 10553 	CleanupStack::PopAndDestroy(5, scheduler); // dummySink, dummySource, file, fs, scheduler

 10555 	__MM_HEAP_MARKEND;

 10556 	return iTestResult;

 10557 	}

 10561 /**

 10562  *

 10563  * CTestStep_MMF_SRSSNK_U_0201 constructor

 10564  *

 10565  * @xxxx

 10566  *

 10567  */

 10568 CTestStep_MMF_SRSSNK_U_0201::CTestStep_MMF_SRSSNK_U_0201()

 10569 	{

 10570 	// store the name of this test case

 10571 	// this is the name that is used by the script file

 10572 	// Each test step initialises it's own name

 10573 	iTestStepName = _L("MM-MMF-SRSSNK-U-0201");

 10574 	}

 10576 /**

 10577  *

 10578  * CTestStep_MMF_SRSSNK_U_0201 destructor

 10579  *

 10580  * @xxxx

 10581  *

 10582  */

 10583 CTestStep_MMF_SRSSNK_U_0201::~CTestStep_MMF_SRSSNK_U_0201()

 10584 	{

 10585 	}

 10587 /**

 10588  *

 10589  * CTestStep_MMF_SRSSNK_U_0201

 10590  *

 10591  * Test creation/destruction of descriptor source.

 10592  *

 10593  * @xxxx

 10594  */

 10595 TVerdict CTestStep_MMF_SRSSNK_U_0201::DoTestStepL()

 10596 	{

 10597 	__MM_HEAP_MARK;

 10599 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10600 	CleanupStack::PushL(scheduler);

 10601 	CActiveScheduler::Install(scheduler);

 10603 	// Test construction/destruction.

 10604 	TBuf8<1> configDes;

 10605 	TNewSourceTestStep testStep(KUidMmfAudioInput, configDes);

 10606 	DoTest(testStep, _L("Construct audio source"), KErrNone);

 10608 	// Create dummy sink.

 10609 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10610 	CleanupStack::PushL(dummySink);

 10612 	// Create an audio source.

 10613 	MDataSource* source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

 10614 	CleanupDeletePushL(source);

 10616 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10617 	source->SourcePrimeL();

 10619 	// Test that the source is initialised correctly.

 10620 	TSourceTypeTestStep testStep2(source, KUidMmfAudioInput, KMMFFourCCCodePCM16, ETrue);

 10621 	DoTest(testStep2, _L("Audio source type"), KErrNone);

 10623 	TCanCreateSourceBufferTestStep testStep3(source, ETrue);

 10624 	DoTest(testStep3, _L("Audio Can create source buffer"), KErrNone);

 10626 	TSourceSampleConvertTestStep testStep4(source, EFalse);

 10627 	DoTest(testStep4, _L("Audio source sample convert"), KErrNone);

 10629 	// Test that the audio source is initialised correctly.

 10630 	CMMFAudioInput* sourceAudioInput = STATIC_CAST(CMMFAudioInput*, source);

 10632 	// XXX These fns. go bang after construction. This is not good.

 10633 	// They are ok, provided we have logged on and called SourcePrimeL().

 10634 	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND

 10635 	if (sourceAudioInput->SoundDevice().Volume() != 0)

 10636 	#else

 10637 	if (sourceAudioInput->SoundDevice().Volume() != (sourceAudioInput->SoundDevice().MaxVolume() + 1) / 2)

 10638 	#endif

 10639 		{

 10640 		#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND

 10641 		INFO_PRINTF1(_L("Audio Input: Device volume != 0\n"));

 10642 		#else

 10643 		INFO_PRINTF2(_L("Audio Input: Device volume != %d\n"), (sourceAudioInput->SoundDevice().MaxVolume() + 1) / 2);

 10644 		#endif

 10645 		iTestResult = EFail;

 10646 		}

 10648 	if (sourceAudioInput->BytesPlayed() != 0)

 10649 		{

 10650 		INFO_PRINTF1(_L("Audio Input: Bytes played != 0\n"));

 10651 		iTestResult = EFail;

 10652 		}

 10654 	CleanupStack::PopAndDestroy(source);

 10656 	CleanupStack::PopAndDestroy(dummySink);

 10657 	CleanupStack::PopAndDestroy(scheduler);

 10659 	__MM_HEAP_MARKEND;

 10660 	return iTestResult;

 10661 	}

 10665 /**

 10666  *

 10667  * CTestStep_MMF_SRSSNK_U_0202 constructor

 10668  *

 10669  * @xxxx

 10670  *

 10671  */

 10672 CTestStep_MMF_SRSSNK_U_0202::CTestStep_MMF_SRSSNK_U_0202()

 10673 	{

 10674 	// store the name of this test case

 10675 	// this is the name that is used by the script file

 10676 	// Each test step initialises it's own name

 10677 	iTestStepName = _L("MM-MMF-SRSSNK-U-0202");

 10678 	}

 10680 /**

 10681  *

 10682  * CTestStep_MMF_SRSSNK_U_0202 destructor

 10683  *

 10684  * @xxxx

 10685  *

 10686  */

 10687 CTestStep_MMF_SRSSNK_U_0202::~CTestStep_MMF_SRSSNK_U_0202()

 10688 	{

 10689 	}

 10691 /**

 10692  *

 10693  * CTestStep_MMF_SRSSNK_U_0202

 10694  *

 10695  * Test creation/destruction of audio sink.

 10696  *

 10697  * @xxxx

 10698  */

 10699 TVerdict CTestStep_MMF_SRSSNK_U_0202::DoTestStepL()

 10700 	{

 10701 	__MM_HEAP_MARK;

 10703 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10704 	CleanupStack::PushL(scheduler);

 10705 	CActiveScheduler::Install(scheduler);

 10707 	// Test construction/destruction.

 10708 	TBuf8<1> configDes;

 10709 	TNewSinkTestStep testStep(KUidMmfAudioOutput, configDes);

 10710 	DoTest(testStep, _L("Construct audio sink"), KErrNone);

 10712 	// Create a dummy source.

 10713 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 10714 	CleanupStack::PushL(dummySource);

 10716 	// Create an audio sink.

 10717 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, configDes);

 10718 	CleanupDeletePushL(sink);

 10720 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

 10721 	sink->SinkPrimeL();

 10723 	// Test that the sink is initialised correctly.

 10724 	TSinkTypeTestStep testStep2(sink, KUidMmfAudioOutput, KMMFFourCCCodePCM16, ETrue);

 10725 	DoTest(testStep2, _L("Audio sink type"), KErrNone);

 10727 	TCanCreateSinkBufferTestStep testStep3(sink, ETrue);

 10728 	DoTest(testStep3, _L("Audio Can create sink buffer"), KErrNone);

 10730 	// Test that the audio sink is initialised correctly.

 10731 	CMMFAudioOutput* sinkAudioOutput = STATIC_CAST(CMMFAudioOutput*, sink);

 10732 	if (sinkAudioOutput->BytesPlayed() != 0)

 10733 		{

 10734 		INFO_PRINTF1(_L("Audio Input: Bytes played != 0\n"));

 10735 		iTestResult = EFail;

 10736 		}

 10738 	CleanupStack::PopAndDestroy(sink);

 10740 	CleanupStack::PopAndDestroy(dummySource);

 10741 	CleanupStack::PopAndDestroy(scheduler);

 10743 	__MM_HEAP_MARKEND;

 10744 	return iTestResult;

 10745 	}

 10748 /**

 10749  *

 10750  * CTestStep_MMF_SRSSNK_U_0203 constructor

 10751  *

 10752  * @xxxx

 10753  *

 10754  */

 10755 CTestStep_MMF_SRSSNK_U_0203::CTestStep_MMF_SRSSNK_U_0203()

 10756 	{

 10757 	// store the name of this test case

 10758 	// this is the name that is used by the script file

 10759 	// Each test step initialises it's own name

 10760 	iTestStepName = _L("MM-MMF-SRSSNK-U-0203");

 10761 	}

 10763 /**

 10764  *

 10765  * CTestStep_MMF_SRSSNK_U_0203 destructor

 10766  *

 10767  * @xxxx

 10768  *

 10769  */

 10770 CTestStep_MMF_SRSSNK_U_0203::~CTestStep_MMF_SRSSNK_U_0203()

 10771 	{

 10772 	}

 10774 /**

 10775  *

 10776  * CTestStep_MMF_SRSSNK_U_0203

 10777  *

 10778  * Test audio source misc. fns.

 10779  *

 10780  * @xxxx

 10781  */

 10782 TVerdict CTestStep_MMF_SRSSNK_U_0203::DoTestStepL()

 10783 	{

 10784 	__MM_HEAP_MARK;

 10786 	const TInt KDevSoundMaxFrameSize = 0x4000;  //16K from SoundDeviceBody.h

 10788 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10789 	CleanupStack::PushL(scheduler);

 10790 	CActiveScheduler::Install(scheduler);

 10792 	// Create a dummy sink.

 10793 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10794 	CleanupStack::PushL(dummySink);

 10796 	// Create an audio source.

 10797 	TBuf8<1> configDes;

 10798 	MDataSource* source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

 10799 	CleanupDeletePushL(source);

 10801 	// Test create source buffer.

 10802 	TCreateSourceBuffer1TestStep testStep(ESourceTypeAudio, dummySink, KUidMmfPtrBuffer, ETrue, KDevSoundMaxFrameSize);

 10804 	DoTest(testStep, _L("Audio source CreateSourceBuffer1"), KErrNone);

 10808 	TCreateSourceBuffer2TestStep testStep2(ESourceTypeAudio, dummySink, NULL, KUidMmfPtrBuffer, ETrue, KDevSoundMaxFrameSize);

 10812 	DoTest(testStep2, _L("Audio source CreateSourceBuffer2"), KErrNone);

 10814 	CMMFAudioInput* sourceAudioInput = STATIC_CAST(CMMFAudioInput*, source);

 10815 	TAudioInputCreateSourceBuffer1TestStep testStep3(sourceAudioInput);

 10816 	DoTest(testStep3, _L("Audio source CreateSourceBuffer3"), KErrNone);

 10818 	TAudioInputCreateSourceBuffer2TestStep testStep4(sourceAudioInput, NULL);

 10819 	DoTest(testStep4, _L("Audio source CreateSourceBuffer4"), KErrNone);

 10821 	// Test the rest...

 10822 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10824 	TFourCC fourCC = KMMFFourCCCodePCM16;

 10825 	TFourCC emptyFourCC;

 10827 	TBufC8<5> fourCCString(KEmptyFourCCCode);

 10828 	TPtr8 fourCCPtr = fourCCString.Des();

 10829 	TPtr8 fourCCPtr1(&fourCCPtr[0], 4);

 10830 	emptyFourCC.FourCC(&fourCCPtr1);

 10831 	source->NegotiateSourceL(*dummySink);

 10833 	TMediaId mediaId;

 10834 	if ((source->SourceDataTypeCode(mediaId) != fourCC) && (source->SourceDataTypeCode(mediaId) != emptyFourCC))

 10835 		{

 10836 		INFO_PRINTF1(_L("Audio Input: NegotiateL source code does not match\n"));

 10837 		iTestResult = EFail;

 10838 		}

 10840 	source->SourcePrimeL();

 10841 	source->SourcePlayL();

 10842 	source->SourcePauseL();

 10843 	source->SourceStopL();

 10845 	TMMFPrioritySettings prioritySettings;

 10846 	source->SetSourcePrioritySettings(prioritySettings);

 10848 	source->SourceThreadLogoff();

 10850 	CleanupStack::PopAndDestroy(source);

 10852 	CleanupStack::PopAndDestroy(dummySink);

 10853 	CleanupStack::PopAndDestroy(scheduler);

 10855 	__MM_HEAP_MARKEND;

 10856 	return iTestResult;

 10857 	}

 10859 /**

 10860  *

 10861  * CTestStep_MMF_SRSSNK_U_0204 constructor

 10862  *

 10863  * @xxxx

 10864  *

 10865  */

 10866 CTestStep_MMF_SRSSNK_U_0204::CTestStep_MMF_SRSSNK_U_0204()

 10867 	{

 10868 	// store the name of this test case

 10869 	// this is the name that is used by the script file

 10870 	// Each test step initialises it's own name

 10871 	iTestStepName = _L("MM-MMF-SRSSNK-U-0204");

 10872 	}

 10874 /**

 10875  *

 10876  * CTestStep_MMF_SRSSNK_U_0204 destructor

 10877  *

 10878  * @xxxx

 10879  *

 10880  */

 10881 CTestStep_MMF_SRSSNK_U_0204::~CTestStep_MMF_SRSSNK_U_0204()

 10882 	{

 10883 	}

 10885 /**

 10886  *

 10887  * CTestStep_MMF_SRSSNK_U_0204

 10888  *

 10889  * Functional test of audio input

 10890  * FillBuifferL test.

 10891  *

 10892  * @xxxx

 10893  */

 10894 TVerdict CTestStep_MMF_SRSSNK_U_0204::DoTestStepL()

 10895 	{

 10896 	__MM_HEAP_MARK;

 10898 	// Initialise thread active scheduler.

 10899 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 10900 	CleanupStack::PushL(scheduler);

 10901 	CActiveScheduler::Install(scheduler);

 10903 	// Create valid buffer.

 10904 	// NB: a valid buffer will be created by DevSound through asynchronous buffer creation.

 10905 	CMMFDescriptorBuffer* validBuffer = NULL;

 10907 	// Create a dummy sink.

 10908 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 10909 	CleanupStack::PushL(dummySink);

 10911 	// Create an audio source.

 10912 	TBuf8<1> configDes;

 10913 	MDataSource* source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

 10914 	CleanupDeletePushL(source);

 10916 	// Test fill source buffer.

 10917 	User::LeaveIfError(source->SourceThreadLogon(*dummySink));

 10918 	source->NegotiateSourceL(*dummySink);

 10919 	source->SourcePrimeL();

 10921 	// Create a test (invalid) buffer.

 10922 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

 10923 	CleanupStack::PushL(testBuffer);

 10925 	// Invalid fill buffer.

 10926 	TAudioInputFillBufferTestStep testStep(source, testBuffer, dummySink);

 10927 	DoTest(testStep, _L("Audio Input: FillBufferL"), KErrNotSupported);

 10928 	CleanupStack::PopAndDestroy(testBuffer);

 10931 	// If we have buffer cycling switched on the DevSound, allocs will occur as

 10932 	// the buffers are switched over. This will cause the __MM_HEAP_MARKENDC() macro to fail.

 10933 	TUint expectedAllocs=0;

 10935 	// Valid fill buffer.

 10936 	TAudioInputFillBufferTestStep testStep2(source, validBuffer, dummySink);

 10937 	DoTest(testStep2, _L("Audio Input: FillBufferL"), KErrNone,expectedAllocs);

 10939 	// Valid fill buffer. (Make multiple requests)

 10940 	TAudioInputFillBuffer2TestStep testStep3(source, validBuffer, dummySink);

 10941 	DoTest(testStep3, _L("Audio Input: FillBufferL"), KErrNone,expectedAllocs);

 10943 	// XXX Valid fill buffer. (Make multiple requests at once)

 10944 	// removed below lines because the audio input currently doesn't support multiple requests.

 10945 	// TAudioInputFillBuffer3TestStep testStep4(source, validBuffer, dummySink);

 10946 	// DoTest(testStep4, _L("Audio Input: FillBufferL"), KErrNone);

 10948 	CleanupStack::PopAndDestroy(source);

 10950 	// Repeat tests, creating a source each time.

 10951 	// Valid fill buffer.

 10952 	TAudioInputFillBuffer4TestStep testStep5(validBuffer, dummySink);

 10953 	DoTest(testStep5, _L("Audio Input: FillBufferL"), KErrNone);

 10955 	// Valid fill buffer. (Make multiple requests)

 10956 	TAudioInputFillBuffer5TestStep testStep6(validBuffer, dummySink);

 10957 	DoTest(testStep6, _L("Audio Input: FillBufferL"), KErrNone);

 10959 	// xxx Valid fill buffer. (Make multiple requests at once)

 10960 	// removed below lines because the audio input currently doesn't support multiple requests.

 10961 	// TAudioInputFillBuffer6TestStep testStep7(validBuffer, dummySink);

 10962 	// DoTest(testStep7, _L("Audio Input: FillBufferL"), KErrNone);

 10964 	// Valid fill buffer + pause + fill (should pass, we can now pause AudioInput and still request data already captured)

 10965 	TAudioInputFillBuffer7TestStep testStep8(validBuffer, dummySink);

 10966 	DoTest(testStep8, _L("Audio Input: FillBufferL"), KErrNone);

 10968 	// Valid fill buffer + stop + fill (should fail)

 10969 	TAudioInputFillBuffer8TestStep testStep9(validBuffer, dummySink);

 10970 	DoTest(testStep9, _L("Audio Input: FillBufferL"), KErrNotReady);

 10972 	CleanupStack::PopAndDestroy(2, scheduler); // dummySink, scheduler

 10974 	__MM_HEAP_MARKEND;

 10975 	return iTestResult;

 10976 	}

 10978 /**

 10979  *

 10980  * CTestStep_MMF_SRSSNK_U_0205 constructor

 10981  *

 10982  * @xxxx

 10983  *

 10984  */

 10985 CTestStep_MMF_SRSSNK_U_0205::CTestStep_MMF_SRSSNK_U_0205()

 10986 	{

 10987 	// store the name of this test case

 10988 	// this is the name that is used by the script file

 10989 	// Each test step initialises it's own name

 10990 	iTestStepName = _L("MM-MMF-SRSSNK-U-0205");

 10991 	}

 10993 /**

 10994  *

 10995  * CTestStep_MMF_SRSSNK_U_0205 destructor

 10996  *

 10997  * @xxxx

 10998  *

 10999  */

 11000 CTestStep_MMF_SRSSNK_U_0205::~CTestStep_MMF_SRSSNK_U_0205()

 11001 	{

 11002 	}

 11004 /**

 11005  *

 11006  * CTestStep_MMF_SRSSNK_U_0205

 11007  *

 11008  * Functional test of audio input source.

 11009  * BufferEmptiedL() test.

 11010  *

 11011  * @xxxx

 11012  */

 11013 TVerdict CTestStep_MMF_SRSSNK_U_0205::DoTestStepL()

 11014 	{

 11015 	__MM_HEAP_MARK;

 11017 	iTestResult = EFail;

 11019 	// Create valid buffer.

 11020 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

 11021 	CleanupStack::PushL(validBuffer);

 11023 	// Create source file.

 11024 	TBuf8<1> configDes;

 11025 	MDataSource* source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

 11026 	CleanupDeletePushL(source);

 11028 	// Test BufferEmptiedL

 11029 	TRAPD(err, source->BufferEmptiedL(validBuffer));

 11030 	if (err == KErrNone)

 11031 		{

 11032 		iTestResult = EPass;

 11033 		}

 11035 	CleanupStack::PopAndDestroy(2, validBuffer); // source, validBuffer

 11037 	__MM_HEAP_MARKEND;

 11038 	return iTestResult;

 11039 	}

 11041 /**

 11042  *

 11043  * CTestStep_MMF_SRSSNK_U_0206 constructor

 11044  *

 11045  * @xxxx

 11046  *

 11047  */

 11048 CTestStep_MMF_SRSSNK_U_0206::CTestStep_MMF_SRSSNK_U_0206()

 11049 	{

 11050 	// store the name of this test case

 11051 	// this is the name that is used by the script file

 11052 	// Each test step initialises it's own name

 11053 	iTestStepName = _L("MM-MMF-SRSSNK-U-0206");

 11054 	}

 11056 /**

 11057  *

 11058  * CTestStep_MMF_SRSSNK_U_0206 destructor

 11059  *

 11060  * @xxxx

 11061  *

 11062  */

 11063 CTestStep_MMF_SRSSNK_U_0206::~CTestStep_MMF_SRSSNK_U_0206()

 11064 	{

 11065 	}

 11067 /**

 11068  *

 11069  * CTestStep_MMF_SRSSNK_U_0206

 11070  *

 11071  * Functional test of audio input source.

 11072  * Source custom commands test.

 11073  *

 11074  * @xxxx

 11075  */

 11076 TVerdict CTestStep_MMF_SRSSNK_U_0206::DoTestStepL()

 11077 	{

 11078 	__MM_HEAP_MARK;

 11080 	iTestResult = EFail;

 11081 	TUid testControllerUid = { KMmfTestControllerUid };

 11082 	RMMFController dummyController;

 11083 	TMMFPrioritySettings prioritySettings;

 11084 	TMMFMessageDestinationPckg destination;

 11085 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

 11086 	CleanupClosePushL(dummyController);

 11088 	TBuf8<1> dummyArgs;

 11089 	User::LeaveIfError(dummyController.AddDataSource(KUidMmfAudioInput, dummyArgs));

 11090 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSource, dummyArgs, dummyArgs);

 11091 	if (err == KErrNotSupported)

 11092 		{

 11093 		iTestResult = EPass;

 11094 		}

 11095 	else

 11096 		{

 11097 		INFO_PRINTF2(_L("File source SourceCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

 11098 		}

 11100 	CleanupStack::PopAndDestroy(); // dummyController

 11102 	__MM_HEAP_MARKEND;

 11103 	return iTestResult;

 11104 	}

 11106 /**

 11107  *

 11108  * CTestStep_MMF_SRSSNK_U_0207 constructor

 11109  *

 11110  * @xxxx

 11111  *

 11112  */

 11113 CTestStep_MMF_SRSSNK_U_0207::CTestStep_MMF_SRSSNK_U_0207()

 11114 	{

 11115 	// store the name of this test case

 11116 	// this is the name that is used by the script file

 11117 	// Each test step initialises it's own name

 11118 	iTestStepName = _L("MM-MMF-SRSSNK-U-0207");

 11119 	}

 11121 /**

 11122  *

 11123  * CTestStep_MMF_SRSSNK_U_0207 destructor

 11124  *

 11125  * @xxxx

 11126  *

 11127  */

 11128 CTestStep_MMF_SRSSNK_U_0207::~CTestStep_MMF_SRSSNK_U_0207()

 11129 	{

 11130 	}

 11132 /**

 11133  *

 11134  * CTestStep_MMF_SRSSNK_U_0207

 11135  *

 11136  * Functional test of audio input source.

 11137  * Misc. fns. test.

 11138  *

 11139  * @xxxx

 11140  */

 11141 TVerdict CTestStep_MMF_SRSSNK_U_0207::DoTestStepL()

 11142 	{

 11143 	__MM_HEAP_MARK;

 11145 	// Initialise thread active scheduler.

 11146 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 11147 	CleanupStack::PushL(scheduler);

 11148 	CActiveScheduler::Install(scheduler);

 11150 	// Create a dummy sink.

 11151 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 11152 	CleanupStack::PushL(dummySink);

 11154 	// Create source file.

 11155 	TBuf8<1> configDes;

 11156 	iSource = STATIC_CAST(CMMFAudioInput*, MDataSource::NewSourceL(KUidMmfAudioInput, configDes));

 11157 	CleanupStack::PushL(iSource);

 11159 	User::LeaveIfError(iSource->SourceThreadLogon(*dummySink));

 11160 	iSource->SourcePrimeL();

 11162 	iSource->SoundDevice().InitializeL(*this, EMMFStatePlaying);

 11163 	CActiveScheduler::Start();	// wait for InitializeComplete callback

 11165 	//post InitializeComplete callback

 11167 	if(iError!=KErrNone)

 11168 		 iTestResult=EFail;

 11171 	CleanupStack::PopAndDestroy(3,scheduler); // dummySink, iSource, scheduler

 11173 	__MM_HEAP_MARKEND;

 11174 	return iTestResult;

 11175 		}

 11177 void CTestStep_MMF_SRSSNK_U_0207::InitializeComplete(TInt aError)

 11178 	{

 11179 	CActiveScheduler::Stop();

 11180 	iError=aError;

 11181 	if(iError==KErrNone)

 11182 		{

 11183 	 	TRAP(iError,iSource->SoundDevice().PlayInitL());

 11184 		}

 11186 	}

 11188 /**

 11189  *

 11190  * CTestStep_MMF_SRSSNK_U_0208 constructor

 11191  *

 11192  * @xxxx

 11193  *

 11194  */

 11195 CTestStep_MMF_SRSSNK_U_0208::CTestStep_MMF_SRSSNK_U_0208()

 11196 	{

 11197 	// store the name of this test case

 11198 	// this is the name that is used by the script file

 11199 	// Each test step initialises it's own name

 11200 	iTestStepName = _L("MM-MMF-SRSSNK-U-0208");

 11201 	}

 11203 /**

 11204  *

 11205  * CTestStep_MMF_SRSSNK_U_0208 destructor

 11206  *

 11207  * @xxxx

 11208  *

 11209  */

 11210 CTestStep_MMF_SRSSNK_U_0208::~CTestStep_MMF_SRSSNK_U_0208()

 11211 	{

 11212 	}

 11214 /**

 11215  *

 11216  * CTestStep_MMF_SRSSNK_U_0208

 11217  *

 11218  * Functional test of audio output.

 11219  * Misc. fns. test.

 11220  *

 11221  * @xxxx

 11222  */

 11223 _LIT(KTest208FileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile1.wav");

 11224 _LIT(KTest208SWFileName, "c:\\mm\\mmf\\testfiles\\srssnk\\MMFTestFile2.wav");

 11225 // DevSound now calculates it's own buffer size depending on the Sample Rate,

 11226 // bytes per channel & channels etc :

 11227 const TUint KBytesPerSample8 = 2;

 11228 const TUint KChannels8 = 1;

 11229 const TUint KDevSoundDeltaFrameSize = 0x800; //2K

 11230 const TUint KAudioOutputDefaultFrameSize22K =

 11231 	(((22*1024*KBytesPerSample8*KChannels8)/4)+ (KDevSoundDeltaFrameSize-1)) &~ (KDevSoundDeltaFrameSize-1);

 11232 TVerdict CTestStep_MMF_SRSSNK_U_0208::DoTestStepL()

 11233 	{

 11234 	__MM_HEAP_MARK;

 11236 	// Initialise thread active scheduler.

 11237 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 11238 	CleanupStack::PushL(scheduler);

 11239 	CActiveScheduler::Install(scheduler);

 11241 	// Create a dummy source.

 11242 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 11243 	CleanupStack::PushL(dummySource);

 11245 	// Create an audio sink.

 11246 // Test 1

 11247 	// Test create sink buffer.

 11248 	TCreateSinkBufferTestStep1 testStep(KUidMmfPtrBuffer, ETrue, NULL, KAudioOutputDefaultFrameSize22K, dummySource);

 11251 	DoTest(testStep, _L("Audio sink CreateSinkBuffer"), KErrNotSupported);

 11253 // Test 2

 11254 	TCreateSinkBufferTestStep2 testStep2(KUidMmfPtrBuffer, ETrue, NULL, KAudioOutputDefaultFrameSize22K);

 11256 	//DoTest(testStep2, _L("Audio sink CreateSinkBuffer"), KErrArgument);

 11257 	//DevSound WP  if we prime before the logon then the error should be KErrNotReady

 11258 	DoTest(testStep2, _L("Audio sink CreateSinkBuffer"), KErrNotReady);

 11260 // Test 3

 11261 	// Create a new sink.

 11262 	// This time configured correctly.

 11263 	// Create a real source.

 11264 	// Initialise config data.

 11265 	TMMFFileConfig configDes;

 11266 	configDes().iPath = KTest208FileName;

 11267 	MDataSource* realSource = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

 11268 	CleanupDeletePushL(realSource);

 11270 	TUid KWavReadUid = { KMmfUidFormatWAVRead };

 11271 	CMMFFormatDecode* realFormat = CMMFFormatDecode::NewL(KWavReadUid, realSource);

 11272 	CleanupStack::PushL(realFormat);

 11273 	TCreateSinkBufferTestStep3 testStep3(KUidMmfPtrBuffer, ETrue, realFormat, KAudioOutputDefaultFrameSize22K, dummySource);

 11275 	DoTest(testStep3, _L("Audio sink CreateSinkBuffer"), KErrNone);

 11277 	CleanupStack::PopAndDestroy(2, realSource); // realFormat, realSource

 11279 // Test 4

 11280 	// Create a new sink.

 11281 	// This time configured correctly for software conversion.

 11282 	// Create a real source.

 11283 	// Initialise config data.

 11284 	configDes().iPath = KTest208SWFileName;

 11285 	realSource = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

 11286 	CleanupDeletePushL(realSource);

 11288 	realFormat = CMMFFormatDecode::NewL(KWavReadUid, realSource);

 11289 	CleanupStack::PushL(realFormat);

 11291 	TCreateSinkBufferTestStep4 testStep4(KUidMmfPtrBuffer, ETrue, realFormat, KAudioOutputDefaultFrameSize22K, dummySource);

 11293 	DoTest(testStep4, _L("Audio sink CreateSinkBuffer"), KErrNone);

 11295 	CleanupStack::PopAndDestroy(2, realSource); // realFormat, realSource

 11297 	CleanupStack::PopAndDestroy(dummySource);

 11298 	CleanupStack::PopAndDestroy(scheduler);

 11300 	__MM_HEAP_MARKEND;

 11301 	return iTestResult;

 11302 	}

 11304 /**

 11305  *

 11306  * CTestStep_MMF_SRSSNK_U_0209 constructor

 11307  *

 11308  * @xxxx

 11309  *

 11310  */

 11311 CTestStep_MMF_SRSSNK_U_0209::CTestStep_MMF_SRSSNK_U_0209()

 11312 	{

 11313 	// store the name of this test case

 11314 	// this is the name that is used by the script file

 11315 	// Each test step initialises it's own name

 11316 	iTestStepName = _L("MM-MMF-SRSSNK-U-0209");

 11317 	}

 11319 /**

 11320  *

 11321  * CTestStep_MMF_SRSSNK_U_0209 destructor

 11322  *

 11323  * @xxxx

 11324  *

 11325  */

 11326 CTestStep_MMF_SRSSNK_U_0209::~CTestStep_MMF_SRSSNK_U_0209()

 11327 	{

 11328 	}

 11330 /**

 11331  *

 11332  * CTestStep_MMF_SRSSNK_U_0209

 11333  *

 11334  * Functional test of audio input

 11335  * EmptyBuifferL test.

 11336  *

 11337  * @xxxx

 11338  */

 11339 const TInt KDevSoundAllocs = 2;

 11340 TVerdict CTestStep_MMF_SRSSNK_U_0209::DoTestStepL()

 11341 	{

 11342 	__MM_HEAP_MARK;

 11344 	// Create a dummy source.

 11345 	CMMFDummySource* dummySource = new(ELeave) CMMFDummySource;

 11346 	CleanupStack::PushL(dummySource);

 11348 	// Set it to fill buffers it receives.

 11349 	dummySource->SetFillBuffer();

 11351 	// Create a real source.

 11352 	// Initialise config data.

 11353 	TMMFFileConfig configDes;

 11354 	configDes().iPath = KTest208FileName;

 11355 	MDataSource* realSource = MDataSource::NewSourceL(KUidMmfFileSource, configDes);

 11356 	CleanupDeletePushL(realSource);

 11358 	TUid KWavReadUid = { KMmfUidFormatWAVRead };

 11359 	CMMFFormatDecode* realFormat = CMMFFormatDecode::NewL(KWavReadUid, realSource);

 11360 	CleanupStack::PushL(realFormat);

 11362 	// Initialise thread active scheduler.

 11363 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 11364 	CleanupStack::PushL(scheduler);

 11365 	CActiveScheduler::Install(scheduler);

 11367 	// Create valid buffer.

 11368 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

 11369 	CleanupStack::PushL(validBuffer);

 11371 	// Create an audio sink.

 11372 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, configDes);

 11373 	CleanupDeletePushL(sink);

 11375 	// Test empty sink buffer.

 11376 	User::LeaveIfError(sink->SinkThreadLogon(*dummySource));

 11377 	sink->SinkPrimeL();

 11378 	sink->NegotiateL(*realFormat);

 11380 	// Create a test (invalid) buffer.

 11381 	CMMFBuffer* testBuffer = new(ELeave) CMMFTestBuffer;

 11382 	CleanupStack::PushL(testBuffer);

 11384 	// Invalid empty buffer.

 11385 	TAudioOutputEmptyBufferTestStep testStep(sink, testBuffer, dummySource);

 11386 	// Expect two allocs because CMMFDevSound::CBody::SetConfigL()

 11387 	// re-allocates it's buffer to match the sample rate of the input file:

 11388 	// one alloc is for the new CMMFDescriptorBuffer and the other is for

 11389 	// CMMFDescriptorBuffer's internal buffer.

 11390 	DoTest(testStep, _L("Audio Output: EmptyBufferL"), KErrNotSupported, KDevSoundAllocs);

 11391 	CleanupStack::PopAndDestroy(testBuffer);

 11393 	// Valid empty buffer.

 11394 	TAudioOutputEmptyBufferTestStep testStep2(sink, validBuffer, dummySource);

 11395 	testStep2.SetAsynchronousWrite();

 11396 	dummySource->SetActiveScheduler();

 11397 	DoTestStep(testStep2, _L("Audio Output: EmptyBufferL"), KErrNone, KDevSoundAllocs);

 11399 	// Abandon test if the previous step failed because the remaining tests rely on it's success.

 11400 	if (iTestResult != EPass)

 11401 		{

 11402 		CleanupStack::PopAndDestroy(6, dummySource); // sink, validBuffer, scheduler, realFormat, realSource, dummySource

 11403 		__MM_HEAP_MARKEND;

 11404 		return iTestResult;

 11405 		}

 11407 	testStep2.SetAsynchronousWrite();

 11408 	dummySource->SetActiveScheduler();

 11409 	DoTest(testStep2, _L("Audio Output: EmptyBufferL"), KErrNone, KDevSoundAllocs);

 11411 	// Valid empty buffer. (Make multiple requests)

 11412 	TAudioOutputEmptyBuffer2TestStep testStep3(sink, validBuffer, dummySource);

 11413 	DoTest(testStep3, _L("Audio Output: EmptyBufferL"), KErrNone, KDevSoundAllocs);

 11415 	// xxx Valid empty buffer. (Make multiple requests at once)

 11416 	// removed below lines because the audio output currently doesn't support multiple requests.

 11417 	// TAudioOutputFillBuffer3TestStep testStep4(sink, validBuffer, dummySource);

 11418 	// DoTest(testStep4, _L("Audio Output: EmptyBufferL"), KErrNone);

 11420 	CleanupStack::PopAndDestroy(sink);

 11422 	// These next tests create aand destroy their own sinks,

 11423 	// so the CMMFDevSound's buffer allocs shouldn't be counted (see above).

 11425 	// Repeat tests, creating a source each time.

 11426 	// Valid empty buffer.

 11427 	TAudioOutputEmptyBuffer4TestStep testStep5(validBuffer, dummySource, *realFormat);

 11428 	DoTest(testStep5, _L("Audio Output: EmptyBufferL"), KErrNone, 0);

 11430 	// Valid empty buffer. (Make multiple requests)

 11431 	//DevSound WP this test is invalid with HwDevice plugin devsound as you cannot pass

 11432 	//in your own buffer and ask the audio utput to empty it because the buffer

 11433 	//is owned by audio output.  ie the audio output is effectively active and

 11434 	//drives the low itself

 11435 	//	TAudioOutputEmptyBuffer5TestStep testStep6(validBuffer, dummySource, *realFormat);

 11436 	//	DoTest(testStep6, _L("Audio Output: EmptyBufferL"), KErrNone, 0);

 11438 	// xxx Valid empty buffer. (Make multiple requests at once)

 11439 	// removed below lines because the audio output currently doesn't support multiple requests.

 11440 	// TAudioOutputEmptyBuffer6TestStep testStep7(validBuffer, dummySource);

 11441 	// DoTest(testStep7, _L("Audio Output: EmptyBufferL"), KErrNone);

 11443 	// Repeat tests using software conversion.

 11444 	// Don't forget to call CreateSinkBufferL!

 11446 	CleanupStack::PopAndDestroy(5, dummySource); // validBuffer, scheduler, realFormat, realSource, dummySource

 11448 	__MM_HEAP_MARKEND;

 11449 	return iTestResult;

 11450 	}

 11452 /**

 11453  *

 11454  * CTestStep_MMF_SRSSNK_U_0210 constructor

 11455  *

 11456  * @xxxx

 11457  *

 11458  */

 11459 CTestStep_MMF_SRSSNK_U_0210::CTestStep_MMF_SRSSNK_U_0210()

 11460 : CTestStep_MMF_SRSSNK(EFalse)

 11461 	{

 11462 	// store the name of this test case

 11463 	// this is the name that is used by the script file

 11464 	// Each test step initialises it's own name

 11465 	iTestStepName = _L("MM-MMF-SRSSNK-U-0210");

 11466 	}

 11468 /**

 11469  *

 11470  * CTestStep_MMF_SRSSNK_U_0210 destructor

 11471  *

 11472  * @xxxx

 11473  *

 11474  */

 11475 CTestStep_MMF_SRSSNK_U_0210::~CTestStep_MMF_SRSSNK_U_0210()

 11476 	{

 11477 	}

 11479 /**

 11480  *

 11481  * CTestStep_MMF_SRSSNK_U_0210

 11482  *

 11483  * Functional test of audio output source.

 11484  * BufferFilledL() test.

 11485  *

 11486  * @xxxx

 11487  */

 11488 TVerdict CTestStep_MMF_SRSSNK_U_0210::DoTestStepL()

 11489 	{

 11490 	__MM_HEAP_MARK;

 11492 	// This test fails if running a debug StdSourcesAndSinks dll.

 11493 	// So only perform the test on target.

 11495 	CMMFDescriptorBuffer* validBuffer = CMMFDescriptorBuffer::NewL(KTestBufferSize);

 11496 	CleanupStack::PushL(validBuffer);

 11498 	// Create sink.

 11499 	TBuf8<1> configDes;

 11500 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, configDes);

 11501 	CleanupDeletePushL(sink);

 11503 	// Test BufferFilledL

 11504 	sink->BufferFilledL(validBuffer);

 11506 	CleanupStack::PopAndDestroy(2, validBuffer); // sink, validBuffer

 11508 	__MM_HEAP_MARKEND;

 11509 	return iTestResult;

 11510 	}

 11512 /**

 11513  *

 11514  * CTestStep_MMF_SRSSNK_U_0211 constructor

 11515  *

 11516  * @xxxx

 11517  *

 11518  */

 11519 CTestStep_MMF_SRSSNK_U_0211::CTestStep_MMF_SRSSNK_U_0211()

 11520 	{

 11521 	// store the name of this test case

 11522 	// this is the name that is used by the script file

 11523 	// Each test step initialises it's own name

 11524 	iTestStepName = _L("MM-MMF-SRSSNK-U-0211");

 11525 	}

 11527 /**

 11528  *

 11529  * CTestStep_MMF_SRSSNK_U_0211 destructor

 11530  *

 11531  * @xxxx

 11532  *

 11533  */

 11534 CTestStep_MMF_SRSSNK_U_0211::~CTestStep_MMF_SRSSNK_U_0211()

 11535 	{

 11536 	}

 11538 /**

 11539  *

 11540  * CTestStep_MMF_SRSSNK_U_0211

 11541  *

 11542  * Functional test of audio output sink.

 11543  * Sink custom commands test.

 11544  *

 11545  * @xxxx

 11546  */

 11547 TVerdict CTestStep_MMF_SRSSNK_U_0211::DoTestStepL()

 11548 	{

 11549 	__MM_HEAP_MARK;

 11551 	iTestResult = EFail;

 11552 	TUid testControllerUid = { KMmfTestControllerUid };

 11553 	RMMFController dummyController;

 11554 	TMMFPrioritySettings prioritySettings;

 11555 	TMMFMessageDestinationPckg destination;

 11556 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

 11557 	CleanupClosePushL(dummyController);

 11559 	TBuf8<1> dummyArgs;

 11560 	User::LeaveIfError(dummyController.AddDataSink(KUidMmfAudioOutput, dummyArgs));

 11561 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSink, dummyArgs, dummyArgs);

 11562 	if (err == KErrNotSupported)

 11563 		{

 11564 		iTestResult = EPass;

 11565 		}

 11566 	else

 11567 		{

 11568 		INFO_PRINTF2(_L("Audio sink SinkCustomCommand: Expecting KErrNotSupported, actually got %d"), err);

 11569 		}

 11571 	CleanupStack::PopAndDestroy(); // dummyController

 11573 	__MM_HEAP_MARKEND;

 11574 	return iTestResult;

 11575 	}

 11577 /**

 11578  *

 11579  * CTestStep_MMF_SRSSNK_U_0212 constructor

 11580  *

 11581  * @xxxx

 11582  *

 11583  */

 11584 CTestStep_MMF_SRSSNK_U_0212::CTestStep_MMF_SRSSNK_U_0212()

 11585 	{

 11586 	// store the name of this test case

 11587 	// this is the name that is used by the script file

 11588 	// Each test step initialises it's own name

 11589 	iTestStepName = _L("MM-MMF-SRSSNK-U-0212");

 11590 	}

 11592 /**

 11593  *

 11594  * CTestStep_MMF_SRSSNK_U_0212 destructor

 11595  *

 11596  * @xxxx

 11597  *

 11598  */

 11599 CTestStep_MMF_SRSSNK_U_0212::~CTestStep_MMF_SRSSNK_U_0212()

 11600 	{

 11601 	}

 11603 /**

 11604  *

 11605  * CTestStep_MMF_SRSSNK_U_0212

 11606  *

 11607  * Functional test of audio output sink.

 11608  * Misc. fns. test.

 11609  *

 11610  * @xxxx

 11611  */

 11612 TVerdict CTestStep_MMF_SRSSNK_U_0212::DoTestStepL()

 11613 	{

 11614 	// All the MDevSoundObserver fns. are untestable.

 11615 	return iTestResult;

 11616 	}

 11618 /**

 11619  *

 11620  * CTestStep_MMF_SRSSNK_U_0301 constructor

 11621  *

 11622  * @xxxx

 11623  *

 11624  */

 11625 CTestStep_MMF_SRSSNK_U_0301::CTestStep_MMF_SRSSNK_U_0301()

 11626 	{

 11627 	iTestStepName = _L("MM-MMF-SRSSNK-U-0301");

 11628 	}

 11630 /**

 11631  *

 11632  * CTestStep_MMF_SRSSNK_U_0301 destructor

 11633  *

 11634  * @xxxx

 11635  *

 11636  */

 11637 CTestStep_MMF_SRSSNK_U_0301::~CTestStep_MMF_SRSSNK_U_0301()

 11638 	{

 11639 	}

 11641 /**

 11642  *

 11643  * CTestStep_MMF_SRSSNK_U_0301

 11644  *

 11645  * Functional test of audio output sink.

 11646  * Misc. fns. test.

 11647  *

 11648  * @xxxx

 11649  */

 11650 TVerdict CTestStep_MMF_SRSSNK_U_0301::DoTestStepL()

 11651 	{

 11652 	__MM_HEAP_MARK;

 11654 	TPrimeStopTestStep testStep;

 11655 	DoFileTest(testStep, _L("PrimeStop"), KErrNone);

 11657 	__MM_HEAP_MARKEND;

 11658 	return iTestResult;

 11659 	}

 11661 /**

 11662  *

 11663  * CTestStep_MMF_SRSSNK_U_0302

 11664  *

 11665  * Functional test of audio output sink.

 11666  * Misc. fns. test.

 11667  *

 11668  * @xxxx

 11669  */

 11671 CTestStep_MMF_SRSSNK_U_0302::CTestStep_MMF_SRSSNK_U_0302()

 11672 	{

 11673 	iTestStepName = _L("MM-MMF-SRSSNK-U-0302");

 11674 	}

 11676 CTestStep_MMF_SRSSNK_U_0302::~CTestStep_MMF_SRSSNK_U_0302()

 11677 	{

 11678 	}

 11680 TVerdict CTestStep_MMF_SRSSNK_U_0302::DoTestStepL()

 11681 	{

 11682 	__MM_HEAP_MARK;

 11684 	// Initialise thread active scheduler.

 11685 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 11686 	CleanupStack::PushL(scheduler);

 11687 	CActiveScheduler::Install(scheduler);

 11689 	TPrimeStopSinkTestStep testStep;

 11690 	DoFileTest(testStep, _L("PrimeStopSinkTest"), KErrNone);

 11692 	CleanupStack::PopAndDestroy(scheduler);

 11694 	__MM_HEAP_MARKEND;

 11695 	return iTestResult;

 11696 	}

 11699 /**

 11700  *

 11701  * CTestStep_MMF_SRSSNK_U_0400

 11702  * Functional Test of URL Source

 11703  *

 11704  *

 11705  *

 11706  * @xxxx

 11707  */

 11709 _LIT(KTestURLMpg, "http://www.symbian.com/clip/mpg");

 11711 CTestStep_MMF_SRSSNK_U_0400::CTestStep_MMF_SRSSNK_U_0400()

 11712 	{

 11713 	iTestStepName = _L("MM-MMF-SRSSNK-U-0400");

 11714 	}

 11716 CTestStep_MMF_SRSSNK_U_0400::~CTestStep_MMF_SRSSNK_U_0400()

 11717 	{

 11718 	}

 11720 TVerdict CTestStep_MMF_SRSSNK_U_0400::DoTestStepL()

 11721 	{

 11722 	__MM_HEAP_MARK;

 11724 	iTestResult = EFail;

 11725 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11726 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11728 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11730 	CleanupDeletePushL(source);

 11732 	TPtrC urlPtr = source->Url();

 11733 	if (urlPtr == _L("http://www.symbian.com/clip/mpg"))

 11734 		{

 11735 		iTestResult = EPass;

 11736 		}

 11738 	CleanupStack::PopAndDestroy(3);

 11740 	__MM_HEAP_MARKEND;

 11741 	return iTestResult;

 11742 	}

 11746 /**

 11747  *

 11748  * CTestStep_MMF_SRSSNK_U_0405

 11749  * Functional Test of URL Source

 11750  *

 11751  *

 11752  *

 11753  * @xxxx

 11754  */

 11756 CTestStep_MMF_SRSSNK_U_0405::CTestStep_MMF_SRSSNK_U_0405()

 11757 	{

 11758 	iTestStepName = _L("MM-MMF-SRSSNK-U-0405");

 11759 	}

 11761 CTestStep_MMF_SRSSNK_U_0405::~CTestStep_MMF_SRSSNK_U_0405()

 11762 	{

 11763 	}

 11765 TVerdict CTestStep_MMF_SRSSNK_U_0405::DoTestStepL()

 11766 	{

 11767 	__MM_HEAP_MARK;

 11769 	iTestResult = EFail;

 11770 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11771 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11773 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11774 	CleanupDeletePushL(source);

 11775 	TFourCC fourCCCode;

 11776 	TMediaId nullId;

 11778 	fourCCCode = source->SourceDataTypeCode(nullId);

 11779 	if (fourCCCode == KMMFFourCCCodeNULL)

 11780 		{

 11781 		iTestResult = EPass;

 11782 		}

 11784 	CleanupStack::PopAndDestroy(3);

 11786 	__MM_HEAP_MARKEND;

 11787 	return iTestResult;

 11788 	}

 11790 /**

 11791  *

 11792  * CTestStep_MMF_SRSSNK_U_0406

 11793  * Functional Test of URL Source

 11794  *

 11795  *

 11796  *

 11797  * @xxxx

 11798  */

 11800 CTestStep_MMF_SRSSNK_U_0406::CTestStep_MMF_SRSSNK_U_0406()

 11801 	{

 11802 	iTestStepName = _L("MM-MMF-SRSSNK-U-0406");

 11803 	}

 11805 CTestStep_MMF_SRSSNK_U_0406::~CTestStep_MMF_SRSSNK_U_0406()

 11806 	{

 11807 	}

 11809 TVerdict CTestStep_MMF_SRSSNK_U_0406::DoTestStepL()

 11810 	{

 11811 	__MM_HEAP_MARK;

 11813 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11814 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11816 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11817 	CleanupDeletePushL(source);

 11818 	TFourCC fourCCCode;

 11819 	TMediaId nullMediaId;

 11820 	TInt returnValue = 0;

 11822 	returnValue = source->SetSourceDataTypeCode(fourCCCode, nullMediaId);

 11823 	if (returnValue == KErrNotSupported)

 11824 		{

 11825 		iTestResult = EPass;

 11826 		}

 11828 	CleanupStack::PopAndDestroy(3);

 11830 	__MM_HEAP_MARKEND;

 11831 	return iTestResult;

 11832 	}

 11835 /**

 11836  *

 11837  * CTestStep_MMF_SRSSNK_U_0407

 11838  * Functional Test of URL Source

 11839  *

 11840  *

 11841  *

 11842  * @xxxx

 11843  */

 11845 CTestStep_MMF_SRSSNK_U_0407::CTestStep_MMF_SRSSNK_U_0407()

 11846 	{

 11847 	iTestStepName = _L("MM-MMF-SRSSNK-U-0407");

 11848 	}

 11850 CTestStep_MMF_SRSSNK_U_0407::~CTestStep_MMF_SRSSNK_U_0407()

 11851 	{

 11852 	}

 11854 TVerdict CTestStep_MMF_SRSSNK_U_0407::DoTestStepL()

 11855 	{

 11856 	__MM_HEAP_MARK;

 11858 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11859 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11861 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11862 	CleanupDeletePushL(source);

 11863 	TMediaId nullId;

 11865 	TRAPD(err, source->FillBufferL(NULL, NULL, nullId));

 11866 	if (err == KErrNotSupported)

 11867 		{

 11868 		iTestResult = EPass;

 11869 		}

 11871 	CleanupStack::PopAndDestroy(3);

 11873 	__MM_HEAP_MARKEND;

 11874 	return iTestResult;

 11875 	}

 11877 /**

 11878  *

 11879  * CTestStep_MMF_SRSSNK_U_0408

 11880  * Functional Test of URL Source

 11881  *

 11882  *

 11883  *

 11884  * @xxxx

 11885  */

 11887 CTestStep_MMF_SRSSNK_U_0408::CTestStep_MMF_SRSSNK_U_0408()

 11888 	{

 11889 	iTestStepName = _L("MM-MMF-SRSSNK-U-0408");

 11890 	}

 11892 CTestStep_MMF_SRSSNK_U_0408::~CTestStep_MMF_SRSSNK_U_0408()

 11893 	{

 11894 	}

 11896 TVerdict CTestStep_MMF_SRSSNK_U_0408::DoTestStepL()

 11897 	{

 11898 	__MM_HEAP_MARK;

 11900 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11901 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11903 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11904 	CleanupDeletePushL(source);

 11906 	TRAPD(err, source->BufferEmptiedL(NULL));

 11907 	if (err == KErrNotSupported)

 11908 		{

 11909 		iTestResult = EPass;

 11910 		}

 11912 	CleanupStack::PopAndDestroy(3);

 11914 	__MM_HEAP_MARKEND;

 11915 	return iTestResult;

 11916 	}

 11919 /**

 11920  *

 11921  * CTestStep_MMF_SRSSNK_U_0409

 11922  * Functional Test of URL Source

 11923  *

 11924  *

 11925  *

 11926  * @xxxx

 11927  */

 11929 CTestStep_MMF_SRSSNK_U_0409::CTestStep_MMF_SRSSNK_U_0409()

 11930 	{

 11931 	iTestStepName = _L("MM-MMF-SRSSNK-U-0409");

 11932 	}

 11934 CTestStep_MMF_SRSSNK_U_0409::~CTestStep_MMF_SRSSNK_U_0409()

 11935 	{

 11936 	}

 11938 TVerdict CTestStep_MMF_SRSSNK_U_0409::DoTestStepL()

 11939 	{

 11940 	__MM_HEAP_MARK;

 11942 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11943 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11945 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11946 	CleanupDeletePushL(source);

 11948 	TBool srcBuf = source->CanCreateSourceBuffer();

 11949 	if (!srcBuf)

 11950 		{

 11951 		iTestResult = EPass;

 11952 		}

 11954 	CleanupStack::PopAndDestroy(3);

 11956 	__MM_HEAP_MARKEND;

 11957 	return iTestResult;

 11958 	}

 11961 /**

 11962  *

 11963  * CTestStep_MMF_SRSSNK_U_0410

 11964  * Functional Test of URL Source

 11965  *

 11966  *

 11967  *

 11968  * @xxxx

 11969  */

 11971 CTestStep_MMF_SRSSNK_U_0410::CTestStep_MMF_SRSSNK_U_0410()

 11972 	{

 11973 	iTestStepName = _L("MM-MMF-SRSSNK-U-0410");

 11974 	}

 11976 CTestStep_MMF_SRSSNK_U_0410::~CTestStep_MMF_SRSSNK_U_0410()

 11977 	{

 11978 	}

 11980 TVerdict CTestStep_MMF_SRSSNK_U_0410::DoTestStepL()

 11981 	{

 11982 	__MM_HEAP_MARK;

 11984 	iTestResult = EFail;

 11985 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 11986 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 11988 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 11989 	CleanupDeletePushL(source);

 11990 	TMediaId nullId;

 11991 	TBool ref = ETrue;

 11993 	TRAPD(err, source->CreateSourceBufferL(nullId, ref));	// EABI warning removal

 11994 	if (err == KErrNotSupported)

 11995 		{

 11996 		iTestResult = EPass;

 11997 		}

 11999 	CleanupStack::PopAndDestroy(3);

 12001 	__MM_HEAP_MARKEND;

 12002 	return iTestResult;

 12003 	}

 12006 /**

 12007  *

 12008  * CTestStep_MMF_SRSSNK_U_0411

 12009  * Functional Test of URL Source

 12010  *

 12011  *

 12012  *

 12013  * @xxxx

 12014  */

 12016 CTestStep_MMF_SRSSNK_U_0411::CTestStep_MMF_SRSSNK_U_0411()

 12017 	{

 12018 	iTestStepName = _L("MM-MMF-SRSSNK-U-0411");

 12019 	}

 12021 CTestStep_MMF_SRSSNK_U_0411::~CTestStep_MMF_SRSSNK_U_0411()

 12022 	{

 12023 	}

 12025 TVerdict CTestStep_MMF_SRSSNK_U_0411::DoTestStepL()

 12026 	{

 12027 	__MM_HEAP_MARK;

 12029 	iTestResult = EFail;

 12030 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12031 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12033 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12034 	CleanupDeletePushL(source);

 12035 	TMediaId nullId;

 12036 	CMMFDataBuffer* buf2 = CMMFDataBuffer::NewL();

 12037 	CleanupStack::PushL(buf2);

 12038 	TBool ref = ETrue;

 12040 	TRAPD(err, source->CreateSourceBufferL(nullId, *buf2, ref));	// EABI warning removal

 12041 	if (err == KErrNotSupported)

 12042 		{

 12043 		iTestResult = EPass;

 12044 		}

 12046 	CleanupStack::PopAndDestroy(4);

 12048 	__MM_HEAP_MARKEND;

 12049 	return iTestResult;

 12050 	}

 12053 /**

 12054  *

 12055  * CTestStep_MMF_SRSSNK_U_0412

 12056  * Functional Test of URL Source

 12057  *

 12058  *

 12059  *

 12060  * @xxxx

 12061  */

 12063 CTestStep_MMF_SRSSNK_U_0412::CTestStep_MMF_SRSSNK_U_0412()

 12064 	{

 12065 	iTestStepName = _L("MM-MMF-SRSSNK-U-0412");

 12066 	}

 12068 CTestStep_MMF_SRSSNK_U_0412::~CTestStep_MMF_SRSSNK_U_0412()

 12069 	{

 12070 	}

 12072 TVerdict CTestStep_MMF_SRSSNK_U_0412::DoTestStepL()

 12073 	{

 12074 	__MM_HEAP_MARK;

 12076 	iTestResult = EFail;

 12077 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12078 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12080 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12081 	CleanupDeletePushL(source);

 12083 	MAsyncEventHandler* s = NULL;

 12084 	TInt returnValue = source->SourceThreadLogon(*s);

 12085 	if (returnValue == KErrNotSupported)

 12086 		{

 12087 		iTestResult = EPass;

 12088 		}

 12090 	CleanupStack::PopAndDestroy(3);

 12092 	__MM_HEAP_MARKEND;

 12093 	return iTestResult;

 12094 	}

 12097 /**

 12098  *

 12099  * CTestStep_MMF_SRSSNK_U_0413

 12100  * Functional Test of URL Source

 12101  *

 12102  *

 12103  *

 12104  * @xxxx

 12105  */

 12107 CTestStep_MMF_SRSSNK_U_0413::CTestStep_MMF_SRSSNK_U_0413()

 12108 	{

 12109 	iTestStepName = _L("MM-MMF-SRSSNK-U-0413");

 12110 	}

 12112 CTestStep_MMF_SRSSNK_U_0413::~CTestStep_MMF_SRSSNK_U_0413()

 12113 	{

 12114 	}

 12116 TVerdict CTestStep_MMF_SRSSNK_U_0413::DoTestStepL()

 12117 	{

 12118 	__MM_HEAP_MARK;

 12120 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12121 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12123 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12124 	CleanupDeletePushL(source);

 12126 	source->SourceThreadLogoff();

 12128 	CleanupStack::PopAndDestroy(3);

 12130 	__MM_HEAP_MARKEND;

 12131 	return iTestResult;

 12132 	}

 12135 /**

 12136  *

 12137  * CTestStep_MMF_SRSSNK_U_0414

 12138  * Functional Test of URL Source

 12139  *

 12140  *

 12141  *

 12142  * @xxxx

 12143  */

 12145 CTestStep_MMF_SRSSNK_U_0414::CTestStep_MMF_SRSSNK_U_0414()

 12146 	{

 12147 	iTestStepName = _L("MM-MMF-SRSSNK-U-0414");

 12148 	}

 12150 CTestStep_MMF_SRSSNK_U_0414::~CTestStep_MMF_SRSSNK_U_0414()

 12151 	{

 12152 	}

 12154 TVerdict CTestStep_MMF_SRSSNK_U_0414::DoTestStepL()

 12155 	{

 12156 	__MM_HEAP_MARK;

 12158 	iTestResult = EFail;

 12159 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12160 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12162 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12163 	CleanupDeletePushL(source);

 12164 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12165 	CleanupDeletePushL(sink);

 12167 	TRAPD(err, source->NegotiateSourceL(*sink));

 12168 	if (err == KErrNotSupported)

 12169 		{

 12170 		iTestResult = EPass;

 12171 		}

 12173 	CleanupStack::PopAndDestroy(4);

 12175 	__MM_HEAP_MARKEND;

 12176 	return iTestResult;

 12177 	}

 12180 /**

 12181  *

 12182  * CTestStep_MMF_SRSSNK_U_0415

 12183  * Functional Test of URL Source

 12184  *

 12185  *

 12186  *

 12187  * @xxxx

 12188  */

 12190 CTestStep_MMF_SRSSNK_U_0415::CTestStep_MMF_SRSSNK_U_0415()

 12191 	{

 12192 	iTestStepName = _L("MM-MMF-SRSSNK-U-0415");

 12193 	}

 12195 CTestStep_MMF_SRSSNK_U_0415::~CTestStep_MMF_SRSSNK_U_0415()

 12196 	{

 12197 	}

 12199 TVerdict CTestStep_MMF_SRSSNK_U_0415::DoTestStepL()

 12200 	{

 12201 	__MM_HEAP_MARK;

 12203 	iTestResult = EFail;

 12204 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12205 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12207 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12208 	CleanupDeletePushL(source);

 12209 	TBool returnValue = ETrue;

 12211 	returnValue = source->SourceSampleConvert();

 12212 	if (returnValue == EFalse)

 12213 		{

 12214 		iTestResult = EPass;

 12215 		}

 12217 	CleanupStack::PopAndDestroy(3);

 12219 	__MM_HEAP_MARKEND;

 12220 	return iTestResult;

 12221 	}

 12224 /**

 12225  *

 12226  * CTestStep_MMF_SRSSNK_U_0416

 12227  *

 12228  * Functional Test of URL Source

 12229  *

 12230  *

 12231  *

 12232  * @xxxx

 12233  */

 12235 CTestStep_MMF_SRSSNK_U_0416::CTestStep_MMF_SRSSNK_U_0416()

 12236 	{

 12237 	iTestStepName = _L("MM-MMF-SRSSNK-U-0416");

 12238 	}

 12240 CTestStep_MMF_SRSSNK_U_0416::~CTestStep_MMF_SRSSNK_U_0416()

 12241 	{

 12242 	}

 12244 TVerdict CTestStep_MMF_SRSSNK_U_0416::DoTestStepL()

 12245 	{

 12246 	__MM_HEAP_MARK;

 12248 	iTestResult = EFail;

 12249 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12250 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12252 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12253 	CleanupDeletePushL(source);

 12255 	TRAPD(err, source->SourcePrimeL());

 12256 	if (err == KErrNotSupported)

 12257 		{

 12258 		iTestResult = EPass;

 12259 		}

 12261 	CleanupStack::PopAndDestroy(3);

 12263 	__MM_HEAP_MARKEND;

 12264 	return iTestResult;

 12265 	}

 12268 /**

 12269  *

 12270  * CTestStep_MMF_SRSSNK_U_0417

 12271  *

 12272  * Functional Test of URL Source

 12273  *

 12274  *

 12275  *

 12276  * @xxxx

 12277  */

 12279 CTestStep_MMF_SRSSNK_U_0417::CTestStep_MMF_SRSSNK_U_0417()

 12280 	{

 12281 	iTestStepName = _L("MM-MMF-SRSSNK-U-0417");

 12282 	}

 12284 CTestStep_MMF_SRSSNK_U_0417::~CTestStep_MMF_SRSSNK_U_0417()

 12285 	{

 12286 	}

 12288 TVerdict CTestStep_MMF_SRSSNK_U_0417::DoTestStepL()

 12289 	{

 12290 	__MM_HEAP_MARK;

 12292 	iTestResult = EFail;

 12293 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12294 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12296 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12297 	CleanupDeletePushL(source);

 12299 	TRAPD(err, source->SourcePlayL());

 12300 	if (err == KErrNotSupported)

 12301 		{

 12302 		iTestResult = EPass;

 12303 		}

 12305 	CleanupStack::PopAndDestroy(3);

 12307 	__MM_HEAP_MARKEND;

 12308 	return iTestResult;

 12309 	}

 12312 /**

 12313  *

 12314  * CTestStep_MMF_SRSSNK_U_0418

 12315  * Functional Test of URL Source

 12316  *

 12317  *

 12318  *

 12319  * @xxxx

 12320  */

 12322 CTestStep_MMF_SRSSNK_U_0418::CTestStep_MMF_SRSSNK_U_0418()

 12323 	{

 12324 	iTestStepName = _L("MM-MMF-SRSSNK-U-0418");

 12325 	}

 12327 CTestStep_MMF_SRSSNK_U_0418::~CTestStep_MMF_SRSSNK_U_0418()

 12328 	{

 12329 	}

 12331 TVerdict CTestStep_MMF_SRSSNK_U_0418::DoTestStepL()

 12332 	{

 12333 	__MM_HEAP_MARK;

 12335 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12336 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12338 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12339 	CleanupDeletePushL(source);

 12341 	TRAPD(err, source->SourcePauseL());

 12342 	if (err == KErrNotSupported)

 12343 		{

 12344 		iTestResult = EPass;

 12345 		}

 12347 	CleanupStack::PopAndDestroy(3);

 12349 	__MM_HEAP_MARKEND;

 12350 	return iTestResult;

 12351 	}

 12354 /**

 12355  *

 12356  * CTestStep_MMF_SRSSNK_U_0419

 12357  * Functional Test of URL Source

 12358  *

 12359  *

 12360  *

 12361  *

 12362  * @xxxx

 12363  */

 12365 CTestStep_MMF_SRSSNK_U_0419::CTestStep_MMF_SRSSNK_U_0419()

 12366 	{

 12367 	iTestStepName = _L("MM-MMF-SRSSNK-U-0419");

 12368 	}

 12370 CTestStep_MMF_SRSSNK_U_0419::~CTestStep_MMF_SRSSNK_U_0419()

 12371 	{

 12372 	}

 12374 TVerdict CTestStep_MMF_SRSSNK_U_0419::DoTestStepL()

 12375 	{

 12376 	__MM_HEAP_MARK;

 12378 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12379 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12381 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12382 	CleanupDeletePushL(source);

 12384 	TRAPD(err, source->SourceStopL());

 12385 	if (err == KErrNotSupported)

 12386 		{

 12387 		iTestResult = EPass;

 12388 		}

 12390 	CleanupStack::PopAndDestroy(3);

 12392 	__MM_HEAP_MARKEND;

 12393 	return iTestResult;

 12394 	}

 12398 /**

 12399  *

 12400  * CTestStep_MMF_SRSSNK_U_0420

 12401  * Functional Test of URL Source

 12402  *

 12403  *

 12404  *

 12405  * @xxxx

 12406  */

 12408 CTestStep_MMF_SRSSNK_U_0420::CTestStep_MMF_SRSSNK_U_0420()

 12409 	{

 12410 	iTestStepName = _L("MM-MMF-SRSSNK-U-0420");

 12411 	}

 12413 CTestStep_MMF_SRSSNK_U_0420::~CTestStep_MMF_SRSSNK_U_0420()

 12414 	{

 12415 	}

 12417 TVerdict CTestStep_MMF_SRSSNK_U_0420::DoTestStepL()

 12418 	{

 12419 	__MM_HEAP_MARK;

 12421 	iTestResult = EFail;

 12422 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12423 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12425 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12426 	CleanupDeletePushL(source);

 12427 	TMMFPrioritySettings settings;

 12429 	TRAPD(err, source->SetSourcePrioritySettings(settings));

 12430 	if (err == KErrNone)

 12431 		{

 12432 		iTestResult = EPass;

 12433 		}

 12435 	CleanupStack::PopAndDestroy(3);

 12437 	__MM_HEAP_MARKEND;

 12438 	return iTestResult;

 12439 	}

 12442 /**

 12443  *

 12444  * CTestStep_MMF_SRSSNK_U_0421

 12445  * Functional Test of URL Source

 12446  *

 12447  *

 12448  *

 12449  * @xxxx

 12450  */

 12452 CTestStep_MMF_SRSSNK_U_0421::CTestStep_MMF_SRSSNK_U_0421()

 12453 	{

 12454 	iTestStepName = _L("MM-MMF-SRSSNK-U-0421");

 12455 	}

 12457 CTestStep_MMF_SRSSNK_U_0421::~CTestStep_MMF_SRSSNK_U_0421()

 12458 	{

 12459 	}

 12461 TVerdict CTestStep_MMF_SRSSNK_U_0421::DoTestStepL()

 12462 	{

 12463 	__MM_HEAP_MARK;

 12465 	iTestResult = EFail;

 12466 	// Initialise config data.

 12467 	TMMFFileConfig configDes;

 12468 	configDes().iPath = KTest101FileName;

 12470 	TUid testControllerUid = { KMmfTestControllerUid };

 12471 	RMMFController dummyController;

 12472 	TMMFPrioritySettings prioritySettings;

 12473 	TMMFMessageDestinationPckg destination;

 12474 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

 12475 	CleanupClosePushL(dummyController);

 12477 	TBuf8<1> dummyArgs;

 12478 	User::LeaveIfError(dummyController.AddDataSource(KUidMmfUrlSource, configDes));

 12479 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSource, dummyArgs, dummyArgs);

 12481 	if (err == KErrNotSupported)

 12482 		{

 12483 		INFO_PRINTF2(_L("File source SourceCustomCommand: Expected KErrNotSupported, Error: %d"), err);

 12484 		iTestResult = EPass;

 12485 		}

 12487 	CleanupStack::PopAndDestroy(); // dummyController

 12489 	__MM_HEAP_MARKEND;

 12490 	return iTestResult;

 12491 	}

 12494 /*

 12495  *    Sinks

 12496  *

 12497  *

 12498  */

 12500 /**

 12501  *

 12502  * CTestStep_MMF_SRSSNK_U_0500

 12503  * Functional Test of URL Sink

 12504  *

 12505  *

 12506  * @xxxx

 12507  */

 12508 CTestStep_MMF_SRSSNK_U_0500::CTestStep_MMF_SRSSNK_U_0500()

 12509 	{

 12510 	iTestStepName = _L("MM-MMF-SRSSNK-U-0500");

 12511 	}

 12513 CTestStep_MMF_SRSSNK_U_0500::~CTestStep_MMF_SRSSNK_U_0500()

 12514 	{

 12515 	}

 12517 TVerdict CTestStep_MMF_SRSSNK_U_0500::DoTestStepL()

 12518 	{

 12519 	__MM_HEAP_MARK;

 12521 	iTestResult = EFail;

 12522 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12523 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12524 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12526 	CleanupDeletePushL(sink);

 12528 	TPtrC urlPtr = sink->Url();

 12529 	if (urlPtr == _L("http://www.symbian.com/clip/mpg"))

 12530 		{

 12531 		iTestResult = EPass;

 12532 		}

 12534 	CleanupStack::PopAndDestroy(3);

 12536 	__MM_HEAP_MARKEND;

 12537 	return iTestResult;

 12538 	}

 12541 /**

 12542  *

 12543  * CTestStep_MMF_SRSSNK_U_0505

 12544  * Functional Test of URL Sink

 12545  *

 12546  *

 12547  * @xxxx

 12548  */

 12549 CTestStep_MMF_SRSSNK_U_0505::CTestStep_MMF_SRSSNK_U_0505()

 12550 	{

 12551 	iTestStepName = _L("MM-MMF-SRSSNK-U-0505");

 12552 	}

 12554 CTestStep_MMF_SRSSNK_U_0505::~CTestStep_MMF_SRSSNK_U_0505()

 12555 	{

 12556 	}

 12558 TVerdict CTestStep_MMF_SRSSNK_U_0505::DoTestStepL()

 12559 	{

 12560 	__MM_HEAP_MARK;

 12562 	iTestResult = EFail;

 12563 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12564 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12566 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12567 	CleanupDeletePushL(sink);

 12568 	TMediaId nullId;

 12570 	TFourCC fourCCCode = sink->SinkDataTypeCode(nullId);

 12571 	if (fourCCCode == KMMFFourCCCodeNULL)

 12572 		{

 12573 		iTestResult = EPass;

 12574 		}

 12576 	CleanupStack::PopAndDestroy(3);

 12578 	__MM_HEAP_MARKEND;

 12579 	return iTestResult;

 12580 	}

 12584 /**

 12585  *

 12586  * CTestStep_MMF_SRSSNK_U_0506

 12587  * Functional Test of URL Sink

 12588  *

 12589  *

 12590  * @xxxx

 12591  */

 12592 CTestStep_MMF_SRSSNK_U_0506::CTestStep_MMF_SRSSNK_U_0506()

 12593 	{

 12594 	iTestStepName = _L("MM-MMF-SRSSNK-U-0506");

 12595 	}

 12597 CTestStep_MMF_SRSSNK_U_0506::~CTestStep_MMF_SRSSNK_U_0506()

 12598 	{

 12599 	}

 12601 TVerdict CTestStep_MMF_SRSSNK_U_0506::DoTestStepL()

 12602 	{

 12603 	__MM_HEAP_MARK;

 12605 	iTestResult = EFail;

 12606 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12607 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12609 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12610 	CleanupDeletePushL(sink);

 12611 	TMediaId nullId;

 12612 	TFourCC fourCCCode;

 12615 	TInt returnValue = sink->SetSinkDataTypeCode(fourCCCode, nullId);

 12616 	if (returnValue == KErrNotSupported)

 12617 		{

 12618 		iTestResult = EPass;

 12619 		}

 12621 	CleanupStack::PopAndDestroy(3);

 12623 	__MM_HEAP_MARKEND;

 12624 	return iTestResult;

 12625 	}

 12629 /**

 12630  *

 12631  * CTestStep_MMF_SRSSNK_U_0507

 12632  * Functional Test of URL Sink

 12633  *

 12634  *

 12635  * @xxxx

 12636  */

 12637 CTestStep_MMF_SRSSNK_U_0507::CTestStep_MMF_SRSSNK_U_0507()

 12638 	{

 12639 	iTestStepName = _L("MM-MMF-SRSSNK-U-0507");

 12640 	}

 12642 CTestStep_MMF_SRSSNK_U_0507::~CTestStep_MMF_SRSSNK_U_0507()

 12643 	{

 12644 	}

 12646 TVerdict CTestStep_MMF_SRSSNK_U_0507::DoTestStepL()

 12647 	{

 12648 	__MM_HEAP_MARK;

 12650 	iTestResult = EFail;

 12651 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12652 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12654 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12655 	CleanupDeletePushL(sink);

 12656 	TMediaId nullId;

 12658 	TRAPD(err, sink->EmptyBufferL(NULL, NULL, nullId));

 12659 	if (err == KErrNotSupported)

 12660 		{

 12661 		iTestResult = EPass;

 12662 		}

 12664 	CleanupStack::PopAndDestroy(3);

 12666 	__MM_HEAP_MARKEND;

 12667 	return iTestResult;

 12668 	}

 12672 /**

 12673  *

 12674  * CTestStep_MMF_SRSSNK_U_0508

 12675  * Functional Test of URL Sink

 12676  *

 12677  *

 12678  * @xxxx

 12679  */

 12680 CTestStep_MMF_SRSSNK_U_0508::CTestStep_MMF_SRSSNK_U_0508()

 12681 	{

 12682 	iTestStepName = _L("MM-MMF-SRSSNK-U-0508");

 12683 	}

 12685 CTestStep_MMF_SRSSNK_U_0508::~CTestStep_MMF_SRSSNK_U_0508()

 12686 	{

 12687 	}

 12689 TVerdict CTestStep_MMF_SRSSNK_U_0508::DoTestStepL()

 12690 	{

 12691 	__MM_HEAP_MARK;

 12693 	iTestResult = EFail;

 12694 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12695 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12697 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12698 	CleanupDeletePushL(sink);

 12700 	TRAPD(err, sink->BufferFilledL(NULL));

 12701 	if (err == KErrNotSupported)

 12702 		{

 12703 		iTestResult = EPass;

 12704 		}

 12706 	CleanupStack::PopAndDestroy(3);

 12708 	__MM_HEAP_MARKEND;

 12709 	return iTestResult;

 12710 	}

 12714 /**

 12715  *

 12716  * CTestStep_MMF_SRSSNK_U_0509

 12717  * Functional Test of URL Sink

 12718  *

 12719  *

 12720  * @xxxx

 12721  */

 12722 CTestStep_MMF_SRSSNK_U_0509::CTestStep_MMF_SRSSNK_U_0509()

 12723 	{

 12724 	iTestStepName = _L("MM-MMF-SRSSNK-U-0509");

 12725 	}

 12727 CTestStep_MMF_SRSSNK_U_0509::~CTestStep_MMF_SRSSNK_U_0509()

 12728 	{

 12729 	}

 12731 TVerdict CTestStep_MMF_SRSSNK_U_0509::DoTestStepL()

 12732 	{

 12733 	__MM_HEAP_MARK;

 12735 	iTestResult = EFail;

 12736 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12737 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12739 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12740 	CleanupDeletePushL(sink);

 12742 	TBool canCreate = sink->CanCreateSinkBuffer();

 12743 	if (canCreate == EFalse)

 12744 		{

 12745 		iTestResult = EPass;

 12746 		}

 12748 	CleanupStack::PopAndDestroy(3);

 12750 	__MM_HEAP_MARKEND;

 12751 	return iTestResult;

 12752 	}

 12756 /**

 12757  *

 12758  * CTestStep_MMF_SRSSNK_U_0510

 12759  * Functional Test of URL Sink

 12760  *

 12761  *

 12762  * @xxxx

 12763  */

 12764 CTestStep_MMF_SRSSNK_U_0510::CTestStep_MMF_SRSSNK_U_0510()

 12765 	{

 12766 	iTestStepName = _L("MM-MMF-SRSSNK-U-0510");

 12767 	}

 12769 CTestStep_MMF_SRSSNK_U_0510::~CTestStep_MMF_SRSSNK_U_0510()

 12770 	{

 12771 	}

 12773 TVerdict CTestStep_MMF_SRSSNK_U_0510::DoTestStepL()

 12774 	{

 12775 	__MM_HEAP_MARK;

 12777 	iTestResult = EFail;

 12778 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12779 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12781 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12782 	CleanupDeletePushL(sink);

 12783 	TMediaId nullId;

 12784 	TBool reference;

 12786 	TRAPD(err, sink->CreateSinkBufferL(nullId, reference));	// EABI warning removal

 12787 	if (err == KErrNotSupported)

 12788 		{

 12789 		iTestResult = EPass;

 12790 		}

 12792 	CleanupStack::PopAndDestroy(3);

 12794 	__MM_HEAP_MARKEND;

 12795 	return iTestResult;

 12796 	}

 12800 /**

 12801  *

 12802  * CTestStep_MMF_SRSSNK_U_0511

 12803  * Functional Test of URL Sink

 12804  *

 12805  *

 12806  * @xxxx

 12807  */

 12808 CTestStep_MMF_SRSSNK_U_0511::CTestStep_MMF_SRSSNK_U_0511()

 12809 	{

 12810 	iTestStepName = _L("MM-MMF-SRSSNK-U-0511");

 12811 	}

 12813 CTestStep_MMF_SRSSNK_U_0511::~CTestStep_MMF_SRSSNK_U_0511()

 12814 	{

 12815 	}

 12817 TVerdict CTestStep_MMF_SRSSNK_U_0511::DoTestStepL()

 12818 	{

 12819 	__MM_HEAP_MARK;

 12821 	iTestResult = EFail;

 12822 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12823 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12825 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12826 	CleanupDeletePushL(sink);

 12828 	MAsyncEventHandler* s = NULL;

 12829 	TInt returnValue = sink->SinkThreadLogon(*s);

 12830 	if (returnValue == KErrNotSupported)

 12831 		{

 12832 		iTestResult = EPass;

 12833 		}

 12835 	CleanupStack::PopAndDestroy(3);

 12837 	__MM_HEAP_MARKEND;

 12838 	return iTestResult;

 12839 	}

 12843 /**

 12844  *

 12845  * CTestStep_MMF_SRSSNK_U_0512

 12846  * Functional Test of URL Sink

 12847  *

 12848  *

 12849  * @xxxx

 12850  */

 12851 CTestStep_MMF_SRSSNK_U_0512::CTestStep_MMF_SRSSNK_U_0512()

 12852 	{

 12853 	iTestStepName = _L("MM-MMF-SRSSNK-U-0512");

 12854 	}

 12856 CTestStep_MMF_SRSSNK_U_0512::~CTestStep_MMF_SRSSNK_U_0512()

 12857 	{

 12858 	}

 12860 TVerdict CTestStep_MMF_SRSSNK_U_0512::DoTestStepL()

 12861 	{

 12862 	__MM_HEAP_MARK;

 12864 	iTestResult = EFail;

 12865 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12866 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12868 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12869 	CleanupDeletePushL(sink);

 12871 	TRAPD(err, sink->SinkThreadLogoff());

 12872 	if (err == KErrNone)

 12873 		{

 12874 		iTestResult = EPass;

 12875 		}

 12877 	CleanupStack::PopAndDestroy(3);

 12880 	__MM_HEAP_MARKEND;

 12881 	return iTestResult;

 12882 	}

 12886 /**

 12887  *

 12888  * CTestStep_MMF_SRSSNK_U_0513

 12889  * Functional Test of URL Sink

 12890  *

 12891  *

 12892  * @xxxx

 12893  */

 12894 CTestStep_MMF_SRSSNK_U_0513::CTestStep_MMF_SRSSNK_U_0513()

 12895 	{

 12896 	iTestStepName = _L("MM-MMF-SRSSNK-U-0513");

 12897 	}

 12899 CTestStep_MMF_SRSSNK_U_0513::~CTestStep_MMF_SRSSNK_U_0513()

 12900 	{

 12901 	}

 12903 TVerdict CTestStep_MMF_SRSSNK_U_0513::DoTestStepL()

 12904 	{

 12905 	__MM_HEAP_MARK;

 12907 	iTestResult = EFail;

 12908 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12909 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12911 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12912 	CleanupDeletePushL(sink);

 12914 	CMMFUrlSource* source = STATIC_CAST(CMMFUrlSource*, MDataSource::NewSourceL(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)));

 12915 	CleanupDeletePushL(source);

 12917 	TRAPD(err, sink->NegotiateL(*source));

 12918 	if (err == KErrNotSupported)

 12919 		{

 12920 		iTestResult = EPass;

 12921 		}

 12923 	CleanupStack::PopAndDestroy(4);

 12926 	__MM_HEAP_MARKEND;

 12927 	return iTestResult;

 12928 	}

 12932 /**

 12933  *

 12934  * CTestStep_MMF_SRSSNK_U_0514

 12935  * Functional Test of URL Sink

 12936  *

 12937  *

 12938  * @xxxx

 12939  */

 12940 CTestStep_MMF_SRSSNK_U_0514::CTestStep_MMF_SRSSNK_U_0514()

 12941 	{

 12942 	iTestStepName = _L("MM-MMF-SRSSNK-U-0514");

 12943 	}

 12945 CTestStep_MMF_SRSSNK_U_0514::~CTestStep_MMF_SRSSNK_U_0514()

 12946 	{

 12947 	}

 12949 TVerdict CTestStep_MMF_SRSSNK_U_0514::DoTestStepL()

 12950 	{

 12951 	__MM_HEAP_MARK;

 12953 	iTestResult = EFail;

 12954 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12955 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12957 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 12958 	CleanupDeletePushL(sink);

 12960 	TRAPD(err, sink->SinkPrimeL());

 12961 	if (err == KErrNotSupported)

 12962 		{

 12963 		iTestResult = EPass;

 12964 		}

 12966 	CleanupStack::PopAndDestroy(3);

 12968 	__MM_HEAP_MARKEND;

 12969 	return iTestResult;

 12970 	}

 12974 /**

 12975  *

 12976  * CTestStep_MMF_SRSSNK_U_0515

 12977  * Functional Test of URL Sink

 12978  *

 12979  *

 12980  * @xxxx

 12981  */

 12982 CTestStep_MMF_SRSSNK_U_0515::CTestStep_MMF_SRSSNK_U_0515()

 12983 	{

 12984 	iTestStepName = _L("MM-MMF-SRSSNK-U-0515");

 12985 	}

 12987 CTestStep_MMF_SRSSNK_U_0515::~CTestStep_MMF_SRSSNK_U_0515()

 12988 	{

 12989 	}

 12991 TVerdict CTestStep_MMF_SRSSNK_U_0515::DoTestStepL()

 12992 	{

 12993 	__MM_HEAP_MARK;

 12995 	iTestResult = EFail;

 12996 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 12997 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 12999 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 13000 	CleanupDeletePushL(sink);

 13002 	TRAPD(err, sink->SinkPlayL());

 13003 	if (err == KErrNotSupported)

 13004 		{

 13005 		iTestResult = EPass;

 13006 		}

 13008 	CleanupStack::PopAndDestroy(3);

 13010 	__MM_HEAP_MARKEND;

 13011 	return iTestResult;

 13012 	}

 13016 /**

 13017  *

 13018  * CTestStep_MMF_SRSSNK_U_0516

 13019  * Functional Test of URL Sink

 13020  *

 13021  *

 13022  * @xxxx

 13023  */

 13024 CTestStep_MMF_SRSSNK_U_0516::CTestStep_MMF_SRSSNK_U_0516()

 13025 	{

 13026 	iTestStepName = _L("MM-MMF-SRSSNK-U-0516");

 13027 	}

 13029 CTestStep_MMF_SRSSNK_U_0516::~CTestStep_MMF_SRSSNK_U_0516()

 13030 	{

 13031 	}

 13033 TVerdict CTestStep_MMF_SRSSNK_U_0516::DoTestStepL()

 13034 	{

 13035 	__MM_HEAP_MARK;

 13037 	iTestResult = EFail;

 13038 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 13039 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 13041 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 13042 	CleanupDeletePushL(sink);

 13044 	TRAPD(err, sink->SinkPauseL());

 13045 	if (err == KErrNotSupported)

 13046 		{

 13047 		iTestResult = EPass;

 13048 		}

 13050 	CleanupStack::PopAndDestroy(3);

 13052 	__MM_HEAP_MARKEND;

 13053 	return iTestResult;

 13054 	}

 13058 /**

 13059  *

 13060  * CTestStep_MMF_SRSSNK_U_0517

 13061  * Functional Test of URL Sink

 13062  *

 13063  *

 13064  * @xxxx

 13065  */

 13066 CTestStep_MMF_SRSSNK_U_0517::CTestStep_MMF_SRSSNK_U_0517()

 13067 	{

 13068 	iTestStepName = _L("MM-MMF-SRSSNK-U-0517");

 13069 	}

 13071 CTestStep_MMF_SRSSNK_U_0517::~CTestStep_MMF_SRSSNK_U_0517()

 13072 	{

 13073 	}

 13075 TVerdict CTestStep_MMF_SRSSNK_U_0517::DoTestStepL()

 13076 	{

 13077 	__MM_HEAP_MARK;

 13079 	iTestResult = EFail;

 13080 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 13081 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 13083 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 13084 	CleanupDeletePushL(sink);

 13086 	TRAPD(err, sink->SinkStopL());

 13087 	if (err == KErrNotSupported)

 13088 		{

 13089 		iTestResult = EPass;

 13090 		}

 13092 	CleanupStack::PopAndDestroy(3);

 13094 	__MM_HEAP_MARKEND;

 13095 	return iTestResult;

 13096 	}

 13100 /**

 13101  *

 13102  * CTestStep_MMF_SRSSNK_U_0518

 13103  * Functional Test of URL Sink

 13104  *

 13105  *

 13106  * @xxxx

 13107  */

 13108 CTestStep_MMF_SRSSNK_U_0518::CTestStep_MMF_SRSSNK_U_0518()

 13109 	{

 13110 	iTestStepName = _L("MM-MMF-SRSSNK-U-0518");

 13111 	}

 13113 CTestStep_MMF_SRSSNK_U_0518::~CTestStep_MMF_SRSSNK_U_0518()

 13114 	{

 13115 	}

 13117 TVerdict CTestStep_MMF_SRSSNK_U_0518::DoTestStepL()

 13118 	{

 13119 	__MM_HEAP_MARK;

 13121 	iTestResult = EFail;

 13122 	CMMFUrlParams* urlCfg = CMMFUrlParams::NewLC(KTestURLMpg, 1);

 13123 	CBufFlat* urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC();

 13125 	CMMFUrlSink* sink = STATIC_CAST(CMMFUrlSink*, MDataSink::NewSinkL(KUidMmfUrlSink, urlCfgBuffer->Ptr(0)));

 13126 	CleanupDeletePushL(sink);

 13127 	TMMFPrioritySettings settings;

 13129 	TRAPD(err, sink->SetSinkPrioritySettings(settings));

 13130 	if (err == KErrNone)

 13131 		{

 13132 		iTestResult = EPass;

 13133 		}

 13135 	CleanupStack::PopAndDestroy(3);

 13137 	__MM_HEAP_MARKEND;

 13138 	return iTestResult;

 13139 	}

 13143 /**

 13144  *

 13145  * CTestStep_MMF_SRSSNK_U_0519

 13146  * Functional Test of URL Sink

 13147  *

 13148  *

 13149  * @xxxx

 13150  */

 13151 CTestStep_MMF_SRSSNK_U_0519::CTestStep_MMF_SRSSNK_U_0519()

 13152 	{

 13153 	iTestStepName = _L("MM-MMF-SRSSNK-U-0519");

 13154 	}

 13156 CTestStep_MMF_SRSSNK_U_0519::~CTestStep_MMF_SRSSNK_U_0519()

 13157 	{

 13158 	}

 13160 TVerdict CTestStep_MMF_SRSSNK_U_0519::DoTestStepL()

 13161 	{

 13162 	__MM_HEAP_MARK;

 13164 	iTestResult = EFail;

 13165 	// Initialise config data.

 13166 	TMMFFileConfig configDes;

 13167 	configDes().iPath = KTest101FileName;

 13169 	TUid testControllerUid = { KMmfTestControllerUid };

 13170 	RMMFController dummyController;

 13171 	TMMFPrioritySettings prioritySettings;

 13172 	TMMFMessageDestinationPckg destination;

 13173 	User::LeaveIfError(dummyController.Open(testControllerUid, prioritySettings));

 13174 	CleanupClosePushL(dummyController);

 13176 	TBuf8<1> dummyArgs;

 13177 	User::LeaveIfError(dummyController.AddDataSink(KUidMmfUrlSink, configDes));

 13178 	TInt err = dummyController.CustomCommandSync(destination, KDescriptorSink, dummyArgs, dummyArgs);

 13180 	if (err != KErrNotSupported)

 13181 		{

 13182 		INFO_PRINTF2(_L("File source SourceCustomCommand: Expecting KErrNotSupported, Error: %d"), err);

 13183 		}

 13184 	else

 13185 		{

 13186 		iTestResult = EPass;

 13187 		}

 13189 	CleanupStack::PopAndDestroy(); // dummyController

 13191 	__MM_HEAP_MARKEND;

 13192 	return iTestResult;

 13193 	}

 13195 /**

 13196  *

 13197  * CTestStep_MMF_SRSSNK_MultipleStop constructor

 13198  *

 13199  * @xxxx

 13200  *

 13201  */

 13202 CTestStep_MMF_SRSSNK_MultipleStop::CTestStep_MMF_SRSSNK_MultipleStop()

 13203 	{

 13204 	// store the name of this test case

 13205 	// this is the name that is used by the script file

 13206 	// Each test step initialises it's own name

 13207 	iSourceType = ESourceTypeFile;

 13208 	iTestStepName = _L("MM-MMF-SRSSNK-U-0520");

 13209 	}

 13211 /**

 13212  *

 13213  * CTestStep_MMF_SRSSNK_MultipleStop destructor

 13214  *

 13215  * @xxxx

 13216  *

 13217  */

 13218 CTestStep_MMF_SRSSNK_MultipleStop::~CTestStep_MMF_SRSSNK_MultipleStop()

 13219 	{

 13220 	}

 13222 /**

 13223  *

 13224  * CTestStep_MMF_SRSSNK_MultipleStop

 13225  *

 13226  * Functional test of file source.

 13227  * Misc. functions test.

 13228  *

 13229  * @xxxx

 13230  */

 13231 TVerdict CTestStep_MMF_SRSSNK_MultipleStop::DoTestStepL()

 13232 	{

 13233 	__MM_HEAP_MARK;

 13235 	// Initialise config data.

 13236 	TMMFFileConfig configFile;

 13237 	configFile().iPath = KTest101FileName;

 13239 	TInt fileSize;

 13240 	OpenFileL(KTest101FileName, EFileRead);

 13241 	User::LeaveIfError(iFile.Size(fileSize));

 13242 	CloseFile();

 13243 	User::LeaveIfError(iFs.Connect());

 13244 	CleanupClosePushL(iFs);

 13246 	// Create source.

 13247 	MDataSource* source = CreateFileSourceL(iSourceType, iFs, KTest101FileName);

 13248 	CleanupDeletePushL(source);

 13250 	source->SourcePrimeL();

 13251 	source->SourcePlayL();

 13252 	source->SourcePauseL();

 13254 	// call stop twice make sure no leaves occur

 13255 	source->SourceStopL();

 13256 	source->SourceStopL();

 13258 	CleanupStack::PopAndDestroy(2, &iFs); // iFs, source

 13260 	__MM_HEAP_MARKEND;

 13261 	return iTestResult;

 13262 	}

 13265 /**

 13266  *

 13267  * CTestStep_MMF_SRSSNK_U_0600 constructor

 13268  *

 13269  * @xxxx

 13270  *

 13271  */

 13272 CTestStep_MMF_SRSSNK_U_0600::CTestStep_MMF_SRSSNK_U_0600()

 13273 	{

 13274 	iTestStepName = _L("MM-MMF-SRSSNK-U-0600");

 13275 	}

 13277 /**

 13278  *

 13279  * CTestStep_MMF_SRSSNK_U_0600 destructor

 13280  *

 13281  * @xxxx

 13282  *

 13283  */

 13284 CTestStep_MMF_SRSSNK_U_0600::~CTestStep_MMF_SRSSNK_U_0600()

 13285 	{

 13286 	}

 13288 /**

 13289  *

 13290  * CTestStep_MMF_SRSSNK_U_0600

 13291  *

 13292  * CMMFFile::iFilePath and iFileDrive should be initialised for KMMFileHandleSourceUid

 13293  * and KFileHandleUid

 13294  *

 13295  * @xxxx

 13296  */

 13297 TVerdict CTestStep_MMF_SRSSNK_U_0600::DoTestStepL()

 13298 	{

 13299 	__MM_HEAP_MARK;

 13301 	_LIT(KTestFileDrive, "C:");

 13302 	_LIT(KTestFilePath, "\\mm\\mmf\\testfiles\\srssnk\\");

 13304 	TFileName testFileName(KTest101FileName);

 13305 	RFs testFsSession;

 13306 	User::LeaveIfError(testFsSession.Connect());

 13307 	CleanupClosePushL(testFsSession);

 13309 	// Create a file source (KFileHandleUid)

 13310 	CMMFFile* source = static_cast<CMMFFile*>(CreateFileSourceL(ESourceTypeFileHandle, testFsSession, testFileName));

 13311 	CleanupStack::PushL(source);

 13313 	//Check that its FilePath & FileDrive have been populated

 13314 	if ((source->FilePath() != KTestFilePath) || (source->FileDrive() != KTestFileDrive))

 13315 		{

 13316 		iTestResult = EFail;

 13317 		INFO_PRINTF3(_L("Test failed for KFileHandleUid. Path=%S, Drive=%S"), &source->FilePath(), &source->FileDrive());

 13318 		}

 13320 	CleanupStack::PopAndDestroy(source);

 13322 	// Create a file handle source (KMMFileHandleSourceUid)

 13323 	source = static_cast<CMMFFile*>(CreateFileHandleSourceL(testFsSession, testFileName));

 13324 	CleanupStack::PushL(source);

 13326 	//Check that its FilePath & FileDrive have been populated

 13327 	if ((source->FilePath() != KTestFilePath) || (source->FileDrive() != KTestFileDrive))

 13328 		{

 13329 		iTestResult = EFail;

 13330 		INFO_PRINTF3(_L("Test failed for KMMFileHandleSourceUid. Path=%S, Drive=%S"), &source->FilePath(), &source->FileDrive());

 13331 		}

 13333 	CleanupStack::PopAndDestroy(2, &testFsSession); // testFsSession, source

 13335 	__MM_HEAP_MARKEND;

 13336 	return iTestResult;

 13337 	}

 13341 /**

 13342  *

 13343  * CTestStep_MMF_SRSSNK_U_0521 constructor

 13344  *

 13345  * @xxxx

 13346  *

 13347  */

 13348 CTestStep_MMF_SRSSNK_U_0521::CTestStep_MMF_SRSSNK_U_0521()

 13349 	{

 13350 	iTestStepName = _L("MM-MMF-SRSSNK-U-0521");

 13351 	}

 13353 /**

 13354  *

 13355  * CTestStep_MMF_SRSSNK_U_0521 destructor

 13356  *

 13357  * @xxxx

 13358  *

 13359  */

 13360 CTestStep_MMF_SRSSNK_U_0521::~CTestStep_MMF_SRSSNK_U_0521()

 13361 	{

 13362 	}

 13364 /**

 13365  *

 13366  * CTestStep_MMF_SRSSNK_U_0521

 13367  *

 13368  * CR0854 - Provide access to the file data via the CData object

 13369  * @xxxx

 13370  */

 13371 TVerdict CTestStep_MMF_SRSSNK_U_0521::DoTestStepL()

 13372 	{

 13373 	__MM_HEAP_MARK;

 13375 	TFileName testFileName(KTest101FileName);

 13376 	RFs testFsSession;

 13377 	User::LeaveIfError(testFsSession.Connect());

 13378 	CleanupClosePushL(testFsSession);

 13380 	// Create a file source (KFileHandleUid)

 13381 	CMMFFile* source = static_cast<CMMFFile*>(CreateFileSourceL(ESourceTypeFileHandle, testFsSession, testFileName));

 13382 	CleanupStack::PushL(source);

 13383 	source->SourcePrimeL();

 13384 	CData *data = NULL;

 13386 	TInt err = source->Data(data);

 13388 	if (err != KErrNone)

 13389 		{

 13390 		iTestResult = EFail;

 13391 		INFO_PRINTF2(_L("Test failed err =%d"), err);

 13392 		}

 13393 	else

 13394 		{

 13395 		iTestResult = EPass;

 13396 		TInt value = 0;

 13397 		err = data->GetAttribute(EIsProtected, value);

 13398 		if (err != KErrNone || value)

 13399 			{

 13400 			INFO_PRINTF3(_L("Test failed err =%d value = %d"), err, value);

 13401 			iTestResult = EFail;

 13402 			}

 13403 		}

 13405 	CleanupStack::PopAndDestroy(2,&testFsSession); // source, testFsSession

 13407 	__MM_HEAP_MARKEND;

 13408 	return iTestResult;

 13409 	}

 13411 /**

 13412  *

 13413  * CTestStep_MMF_SRSSNK_U_0522 constructor

 13414  *

 13415  * @xxxx

 13416  *

 13417  */

 13418 CTestStep_MMF_SRSSNK_U_0522::CTestStep_MMF_SRSSNK_U_0522()

 13419 	{

 13420 	// store the name of this test case

 13421 	// this is the name that is used by the script file

 13422 	// Each test step initialises it's own name

 13423 	iTestStepName = _L("MM-MMF-SRSSNK-U-0522");

 13424 	}

 13426 /**

 13427  *

 13428  * CTestStep_MMF_SRSSNK_U_0522 destructor

 13429  *

 13430  * @xxxx

 13431  *

 13432  */

 13433 CTestStep_MMF_SRSSNK_U_0522::~CTestStep_MMF_SRSSNK_U_0522()

 13434 	{

 13435 	}

 13437 /**

 13438  *

 13439  * CTestStep_MMF_SRSSNK_U_0522

 13440  *

 13441  * CR0854 - Provide access to the file data via the CData object

 13442  *

 13443  * @xxxx

 13444  */

 13446 TVerdict CTestStep_MMF_SRSSNK_U_0522::DoTestStepL()

 13447 	{

 13448 	__MM_HEAP_MARK;

 13450 	RFs testFsSession;

 13451 	User::LeaveIfError(testFsSession.Connect()) ;

 13452 	CleanupClosePushL(testFsSession);

 13454 	TFileName testFileName(KTest103FileName);

 13455 	CMMFFile* sink = static_cast<CMMFFile*>(CreateFileSinkL(ESinkTypeFile, testFsSession, testFileName));

 13456 	CleanupStack::PushL(sink);

 13458 	// Test that the file has been opened correctly.

 13459 	sink->SinkPrimeL();

 13460 	CData *data = NULL;

 13461 	TInt err = sink->Data(data);

 13463 	if(err != KErrNotSupported )

 13464 		{

 13465 		iTestResult = EFail;

 13466 		INFO_PRINTF2(_L("Test failed err =%d"), err);

 13467 		}

 13468 	else

 13469 		{

 13470 		iTestResult = EPass;

 13471 		}

 13472 	CleanupStack::PopAndDestroy(2,&testFsSession);

 13474 	__MM_HEAP_MARKEND;

 13475 	return iTestResult;

 13476 	}

 13478 /**

 13479  *

 13480  * CTestStep_MMF_SRSSNK_U_0523 constructor

 13481  *

 13482  */

 13483 CTestStep_MMF_SRSSNK_U_0523::CTestStep_MMF_SRSSNK_U_0523()

 13484 	{

 13485 	iTestStepName = _L("MM-MMF-SRSSNK-U-0523");

 13486 	}

 13488 /**

 13489  *

 13490  * CTestStep_MMF_SRSSNK_U_0523 destructor

 13491  *

 13492  */

 13493 CTestStep_MMF_SRSSNK_U_0523::~CTestStep_MMF_SRSSNK_U_0523()

 13494 	{

 13495 	}

 13497 /**

 13498  *

 13499  * CTestStep_MMF_SRSSNK_U_0523

 13500  *

 13501  * PDEF102849 - Invalid Remaining Space value obtained for E:\ (memory card)

 13502  *

 13503  */

 13504 TVerdict CTestStep_MMF_SRSSNK_U_0523::DoTestStepL()

 13505 	{

 13506 	_LIT(KTestFileName, "E:\\unittest\\mmf\\srssnk\\MMFTestFile1.dat");

 13508 	__MM_HEAP_MARK;

 13510 	TInt64 freeSpace = 0;

 13512 	RFs fs;

 13513 	User::LeaveIfError(fs.Connect()) ;

 13514 	CleanupClosePushL(fs);

 13516 	// Create new e: drive to test fix if working on emulator

 13517 #ifdef __WINS__

 13519 	_LIT(KSubstPath, "C:\\");

 13521 	if (fs.SetSubst(KSubstPath, EDriveE) != KErrNone)

 13522 		{

 13523 		CleanupStack::PopAndDestroy(); // fs;

 13524 		__MM_HEAP_MARKEND;

 13525 		return EFail;

 13526 		}

 13528 #endif

 13530 	// Get the free space on the drive.

 13531 	TFileName testFileName(KTestFileName);

 13532 	TParsePtr parser(testFileName);

 13533 	TDriveUnit drive(parser.Drive());

 13534 	TVolumeInfo volInfo;

 13536 	if (fs.Volume(volInfo, drive) == KErrNone)

 13537 		{

 13538 		freeSpace = volInfo.iFree;

 13539 		}

 13541 	// Initialise config data.

 13542 	TMMFFileConfig configFile;

 13543 	configFile().iPath = KTestFileName;

 13545 	CMMFFile* source = static_cast<CMMFFile*>(CreateFileSourceL(ESourceTypeFile, fs, KTestFileName));

 13546 	CleanupStack::PushL(source);

 13548 	// do bytes free test

 13549 	TClipBytesFreeTestStep testStep(source, freeSpace);

 13550 	DoFileTest(testStep, _L("E: drive BytesFree"), KErrNone);

 13552 	CleanupStack::PopAndDestroy(2, &fs);

 13554 	__MM_HEAP_MARKEND;

 13556 	return iTestResult;

 13557 	}

 13559 /**

 13560  *

 13561  * CTestStep_MMF_SRSSNK_U_0524 constructor

 13562  *

 13563  * @xxxx

 13564  *

 13565  */

 13566 CTestStep_MMF_SRSSNK_U_0524::CTestStep_MMF_SRSSNK_U_0524()

 13567 	{

 13568 	// store the name of this test case

 13569 	// this is the name that is used by the script file

 13570 	// Each test step initialises it's own name

 13571 	iTestStepName = _L("MM-MMF-SRSSNK-U-0524");

 13572 	iIsAllocTest = EFalse;

 13573 	}

 13575 /**

 13576  *

 13577  * CTestStep_MMF_SRSSNK_U_0524 destructor

 13578  *

 13579  * @xxxx

 13580  *

 13581  */

 13582 CTestStep_MMF_SRSSNK_U_0524::~CTestStep_MMF_SRSSNK_U_0524()

 13583 	{

 13584 	}

 13586 /**

 13587  *

 13588  * CTestStep_MMF_SRSSNK_U_0524

 13589  *

 13590  * Test audio source misc. fns.

 13591  *

 13592  * @xxxx

 13593  */

 13594 TVerdict CTestStep_MMF_SRSSNK_U_0524::DoTestStepL()

 13595 	{

 13597 	const TInt KDevSoundMaxFrameSize = 0x4000;  //16K from SoundDeviceBody.h

 13599 	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

 13600 	CleanupStack::PushL(scheduler);

 13601 	CActiveScheduler::Install(scheduler);

 13603 	// Create a dummy sink.

 13604 	CMMFDummySink* dummySink = new(ELeave) CMMFDummySink;

 13605 	CleanupStack::PushL(dummySink);

 13607 	// Create an audio source.

 13608 	TBuf8<1> configDes;

 13609 	MDataSource* source = MDataSource::NewSourceL(KUidMmfAudioInput, configDes);

 13610 	CleanupDeletePushL(source);

 13612 	TCreateSourceBuffer3TestStep testStep(ESourceTypeAudio, dummySink, KUidMmfDescriptorBuffer, ETrue, KDevSoundMaxFrameSize);

 13613 	DoTestStep(testStep, _L("Audio source CreateSourceBuffer1"), KErrNone);

 13614 	CleanupStack::PopAndDestroy(source);

 13616 	CleanupStack::PopAndDestroy(dummySink);

 13617 	CleanupStack::PopAndDestroy(scheduler);

 13619 	return iTestResult;

 13620 	}

 13622 TVerdict TCreateSourceBuffer3TestStep::DoTestStepL()

 13623 	{

 13624 	MDataSource* source = NULL;

 13626 	source = CreateSourceL(iSourceType, NULL);

 13628 	User::LeaveIfError(source->SourceThreadLogon(*this));

 13630 	source->SourcePrimeL();

 13631 	TRAPD(err,source->NegotiateSourceL(*iSink));

 13633 	return (err == KErrNone ? EPass : EFail);

 13634 	}

 13636 TInt TCreateSourceBuffer3TestStep::SendEventToClient(const TMMFEvent& aEvent)

 13637 	{

 13638 	if (aEvent.iErrorCode == KErrNoMemory)

 13639 		{

 13640 		CActiveScheduler::Stop();

 13641 		}

 13642 	return KErrNone;

 13643 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--