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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32test\multimedia\t_sound2.cpp

 //

 //

 /**

  @file General test code for the shared chunk sound driver - based on T_SOUND.

 */

 #include <e32test.h>

 #include "t_soundutils.h"

 #include <hal.h>

 #include <e32def.h>

 #include <e32def_private.h>

 // #define SOAKTEST

 const TSoundRate speedTable[] = {ESoundRate48000Hz,ESoundRate44100Hz,ESoundRate32000Hz,ESoundRate29400Hz,

 								 ESoundRate24000Hz,ESoundRate22050Hz,ESoundRate16000Hz,ESoundRate14700Hz,

 								 ESoundRate12000Hz,ESoundRate11025Hz,ESoundRate9600Hz,ESoundRate8820Hz,

 								 ESoundRate8000Hz,ESoundRate7350Hz,(TSoundRate)-1};	// ALL RATES DECENDING

 #define CHECK(aValue) {Test(aValue,__LINE__);}

 #define CHECK_NOERROR(aValue) { TInt v=(aValue); if(v) { Test.Printf(_L("Error value = %d\n"),v); Test(EFalse,__LINE__); }}

 #define CHECK_EQUAL(aValue1,aValue2) { TInt v1=(aValue1); TInt v2=(aValue2); if(v1!=v2) { Test.Printf(_L("Error value = %d\n"),v1); Test(EFalse,__LINE__); }}

 #define CHECK_POSITIVE(aOffset) { if(aOffset<0) { Test.Printf(_L("CHECK_POSITIVE(%d) failed\n"), aOffset); Test(EFalse,__LINE__); } }

 _LIT(KSndLddFileName,"ESOUNDSC.LDD");

 _LIT(KSndPddFileName,"SOUNDSC.PDD");

 RTest Test(_L("T_SOUND2"));

 RSoundSc TxSoundDevice;

 RSoundSc RxSoundDevice;

 TSoundFormatsSupportedV02Buf RecordCapsBuf;

 TSoundFormatsSupportedV02Buf PlayCapsBuf;

 TCurrentSoundFormatV02Buf PlayFormatBuf;

 TCurrentSoundFormatV02Buf RecordFormatBuf;

 LOCAL_C TInt Load()

 	{

 	TInt r;

 	Test.Start(_L("Load sound PDD"));

 	r=User::LoadPhysicalDevice(KSndPddFileName);

 	if (r==KErrNotFound)

 		{

 		Test.End();

 		return(r);

 		}

 	CHECK(r==KErrNone || r==KErrAlreadyExists);

 	r=User::LoadPhysicalDevice(KSndPddFileName);

 	CHECK(r==KErrAlreadyExists);

 	Test.Next(_L("Load sound LDD"));

 	r=User::LoadLogicalDevice(KSndLddFileName);

 	CHECK(r==KErrNone || r==KErrAlreadyExists);

 	r=User::LoadPhysicalDevice(KSndPddFileName);

 	CHECK(r==KErrAlreadyExists);

 	Test.End();

 	return(KErrNone);

 	}

 LOCAL_C void CheckConfig(const TCurrentSoundFormatV02& aConfig,const TSoundFormatsSupportedV02& aCaps)

 	{

 	if (!((1<<(aConfig.iChannels-1)) & aCaps.iChannels))

 		CHECK_NOERROR(ETrue);

 	if (!((1<<aConfig.iRate) & aCaps.iRates))

 		CHECK_NOERROR(ETrue);

 	if (!((1<<aConfig.iEncoding) & aCaps.iEncodings))

 		CHECK_NOERROR(ETrue);

 	if (!((1<<aConfig.iDataFormat) & aCaps.iDataFormats))

 		CHECK_NOERROR(ETrue);

 	}

 ////////////////////////////////////////////////////////////////////////////////

 // Tests

 const TInt KMaxLinearVolume=256;

 const TInt KLinearTodB[KMaxLinearVolume+1] =

 	{

 	0  ,158,170,177,182,186,189,192,194,196,198,200,201,203,204,205,

 	206,207,208,209,210,211,212,213,213,214,215,215,216,217,217,218,

 	218,219,219,220,220,221,221,222,222,223,223,224,224,224,225,225,

 	225,226,226,226,227,227,227,228,228,228,229,229,229,230,230,230,

 	230,231,231,231,231,232,232,232,232,233,233,233,233,234,234,234,

 	234,235,235,235,235,235,236,236,236,236,236,237,237,237,237,237,

 	237,238,238,238,238,238,239,239,239,239,239,239,240,240,240,240,

 	240,240,240,241,241,241,241,241,241,241,242,242,242,242,242,242,

 	242,243,243,243,243,243,243,243,244,244,244,244,244,244,244,244,

 	245,245,245,245,245,245,245,245,245,246,246,246,246,246,246,246,

 	246,246,247,247,247,247,247,247,247,247,247,247,248,248,248,248,

 	248,248,248,248,248,248,249,249,249,249,249,249,249,249,249,249,

 	250,250,250,250,250,250,250,250,250,250,250,250,251,251,251,251,

 	251,251,251,251,251,251,251,251,252,252,252,252,252,252,252,252,

 	252,252,252,252,252,253,253,253,253,253,253,253,253,253,253,253,

 	253,253,254,254,254,254,254,254,254,254,254,254,254,254,254,254,255

 	};

 LOCAL_C void TestBasicPlayFunctions()

 	{

 	TRequestStatus stat[2];

 	Test.Next(_L("Preparing to play..."));

 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	PlayFormatBuf().iChannels = 1;

 	PrintConfig(PlayFormatBuf(),Test);

 	TInt r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 	CHECK_NOERROR(r);

 	// Set the play buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(PlayFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=2;

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;		// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	TxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	PrintBufferConf(bufferConfig,Test);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	TPtr8* tPtr[2];

 	TInt i;

 	for (i=0;i<2;i++)

 		tPtr[i]=new TPtr8(chunk.Base()+bufferConfig.iBufferOffsetList[i],bufSize);

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-249

 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming before playback has commenced.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration.

 							1)	Attempt to resume playback before playback has been started.

 							2)	Attempt to pause playback before playback has been started.

 	@SYMTestExpectedResults	1)	The resume request should complete with KErrNotReady.

 							2)	The pause request should complete with KErrNotReady

 	@SYMREQ					PREQ1073.4 */

 	Test.Printf(_L("Resume when not playing\r\n"));

 	r=TxSoundDevice.Resume();

 	CHECK(r==KErrNotReady)

 	Test.Printf(_L("Pause when not playing\r\n"));

 	r=TxSoundDevice.Pause();

 	CHECK(r==KErrNotReady)

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-237

 	@SYMTestCaseDesc 		Play operation - with zero length.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer

 							configuration. Issue a transfer request from one of the buffers to play data specifying a

 							length of zero.

 	@SYMTestExpectedResults	The play request should complete with KErrNone.

 	@SYMREQ					PREQ1073.4 */

 	Test.Next(_L("Play empty buffer"));

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],0,KSndFlagLastSample);	// Play length of zero

 	User::WaitForRequest(stat[0]);

 	CHECK_EQUAL(stat[0].Int(),KErrNone);

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-238

 	@SYMTestCaseDesc 		Play operation - with a short transfer.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration.

 							1)	Issue a transfer requests from one of the buffers to play data, specifying a length equal to the

 								minimum request size that the device supports - i.e.

 								TSoundFormatsSupportedV02::iRequestMinSize, or 2 bytes, whichever is greater.

 							2)	Issue a transfer requests from one of the buffers to play data, specifying a length equal

 								to twice the minimum request size that the device supports, or 34 bytes, whichever

 								is greater.

 	@SYMTestExpectedResults	1)	The play request should complete with KErrNone.

 							2)	The play request should complete with KErrNone.

 	@SYMREQ					PREQ1073.4 */

 	Test.Next(_L("Play short buffer"));

 	TInt len=Max(2,PlayCapsBuf().iRequestMinSize);

 	Test.Printf(_L("Play length is %d bytes\r\n"),len);

 	tPtr[0]->FillZ(bufSize);

 	tPtr[1]->FillZ(len);

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],len,KSndFlagLastSample);

 	User::WaitForRequest(stat[0]);

 	CHECK_EQUAL(stat[0].Int(),KErrNone);

 	User::WaitForRequest(stat[1]);

 	CHECK_EQUAL(stat[1].Int(),KErrNone);

 	Test.Next(_L("Play a slightly longer buffer"));

 	len=Max(34,(PlayCapsBuf().iRequestMinSize<<1));

 	if (PlayCapsBuf().iRequestMinSize)

 			len&=~(PlayCapsBuf().iRequestMinSize-1);

 	Test.Printf(_L("Play length is %d bytes\r\n"),len);

 	tPtr[1]->FillZ(bufSize);

 	tPtr[0]->FillZ(len);

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[1],bufSize,0); // Play 2nd buffer 1st

 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[0],len,KSndFlagLastSample);

 	User::WaitForRequest(stat[0]);

 	CHECK_EQUAL(stat[0].Int(),KErrNone);

 	User::WaitForRequest(stat[1]);

 	CHECK_EQUAL(stat[1].Int(),KErrNone);

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-240

 	@SYMTestCaseDesc 		Play operation - altering the volume.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

 							so it contains multiple buffers. Using multiple simultaneous play requests, play 4 seconds

 							of continuous tone - with each individual play request consisting of 1/8th second of tone.

 							Each time a request completes, increase the volume slightly - starting at the minimum

 							and ending at maximum volume. (Ensure the last request is marked with the

 							KSndFlagLastSample flag).

 	@SYMTestExpectedResults	The driver should successfully play 4 seconds of tone with all requests completing with

 							KErrNone.

 	@SYMREQ					PREQ1073.4 */

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-250

 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming while playback is in progress.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

 							so it contains multiple buffers. Reset the channel's count of bytes transferred.

 							Using multiple simultaneous play requests, play 4 seconds of continuous tone - with

 							each individual play request consisting of 1/8th second of tone.

 							1)	After 10 requests have completed, pause transfer for 2 seconds, then resume it.

 							2)	After 20 requests have completed, attempt to resume playback while playback is not paused.

 							3)	With only 0.25 second of tone still to play, pause transfer for 1 second, then resume it.

 							4)	10ms after resuming, pause transfer again for 1 second, then resume it.

 							5)	Once transfer has completed, read back the count of bytes transferred.

 	@SYMTestExpectedResults	1)	Playback of the tone should be interrupted for 2 seconds with the pause and resume requests

 								both completing with KErrNone.

 							2)	The resume request should complete with KErrNotReady.

 							3)	Playback of the tone should be interrupted for 1 second with the pause and resume requests

 								both completing with KErrNone.

 							4)	Playback of the tone should be interrupted for 1 second with the pause and resume requests

 								both completing with KErrNone.

 							5)	The count of bytes transferred should not be affected by pausing and resuming playback

 								(i.e. it should equal the value calculated for 4 seconds at the selected sampe rate and

 								number of channels).

 	@SYMREQ					PREQ1073.4 */

 	Test.Next(_L("Playing..."));

 	r=MakeSineTable(PlayFormatBuf());

 	CHECK_NOERROR(r);

 	r=SetToneFrequency(440,PlayFormatBuf());

 	CHECK_NOERROR(r);

 	TxSoundDevice.ResetBytesTransferred();

 	TInt remainingPlayCount = BytesPerSecond(PlayFormatBuf())*4/bufSize;

 	// Set the initial value for the volume.

 	TInt bytesToPlay = remainingPlayCount*bufSize;

 	TInt bytesPlayed = 0;

 	TInt vol = I64LOW(TInt64(KMaxLinearVolume)*TInt64(bytesPlayed)/TInt64(bytesToPlay));

 	vol = KLinearTodB[vol];			// Rather than varying the volume logarithmically (in dB), vary it linearly (as done by MM).

 	TxSoundDevice.SetVolume(vol);

 	// Issue a pair of play requests.

 	WriteTone(*tPtr[0],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

 	WriteTone(*tPtr[1],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

 	TInt lcount = 0;

 	TUint flags;

 	while (remainingPlayCount>2)

 		{

 		// Wait for either of the outstanding play requests to complete.

 		User::WaitForAnyRequest();

 		remainingPlayCount--;

 		// Work out which request this applies to.

 		for (i=0;i<2;i++)

 			{

 			if (stat[i]!=KRequestPending)

 				break;

 			}

 		CHECK(i<2);

 		CHECK_NOERROR(stat[i].Int());

 		// Issue a further play request using the buffer just made free.

 		WriteTone(*tPtr[i],PlayFormatBuf());

 		flags=(remainingPlayCount<=2)?KSndFlagLastSample:0;

 		TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],bufSize,flags);

 		// Adjust the volume

 		bytesPlayed = TxSoundDevice.BytesTransferred();

 		vol = I64LOW(TInt64(KMaxLinearVolume)*TInt64(bytesPlayed)/TInt64(bytesToPlay));

 		vol = KLinearTodB[vol];			// Rather than varying the volume logarithmically (in dB), vary it linearly (as done by MM).

 		Test.Printf(_L("Bytes played = %d (vol = %d)\r\n"),bytesPlayed,vol);

 		TxSoundDevice.SetVolume(vol);

 		if (lcount == 10)

 			{

 			// Do a pause/resume

 			r=TxSoundDevice.Pause();

 			CHECK_NOERROR(r);

 			Test.Printf(_L("Pause 2 seconds\r\n"));

 			User::After(2000000);

 			Test.Printf(_L("Restart\r\n"));

 			r=TxSoundDevice.Resume();

 			CHECK_NOERROR(r);

 			}

 		if (lcount == 20)

 			{

 			Test.Printf(_L("Resume when playing\r\n"));

 			r=TxSoundDevice.Resume();

 			CHECK(r==KErrNotReady)

 			}

 		CHECK_EQUAL(TxSoundDevice.Volume(),vol);

 		CHECK_EQUAL(TxSoundDevice.SetAudioFormat(PlayFormatBuf),KErrInUse);

 		lcount++;

 		}

 	// Last 2 play requests still outstanding - do a pause/resume

 	r=TxSoundDevice.Pause();

 	CHECK_NOERROR(r);

 	Test.Printf(_L("Pause 1 second\r\n"));

 	User::After(1000000);

 	Test.Printf(_L("Restart\r\n"));

 	r=TxSoundDevice.Resume();

 	CHECK_NOERROR(r);

 	bytesPlayed = TxSoundDevice.BytesTransferred();

 	User::After(10000); // 10ms

 	r=TxSoundDevice.Pause();

 	Test.Printf(_L("Bytes played = %d\r\n"),bytesPlayed);

 	CHECK_NOERROR(r);

 	Test.Printf(_L("Pause 1 second\r\n"));

 	User::After(1000000);

 	Test.Printf(_L("Restart\r\n"));

 	r=TxSoundDevice.Resume();

 	CHECK_NOERROR(r);

 	bytesPlayed = TxSoundDevice.BytesTransferred();

 	Test.Printf(_L("Bytes played = %d\r\n"),bytesPlayed);

 	User::WaitForRequest(stat[0]);

 	CHECK_EQUAL(stat[0].Int(),KErrNone);

 	User::WaitForRequest(stat[1]);

 	CHECK_EQUAL(stat[1].Int(),KErrNone);

 	bytesPlayed = TxSoundDevice.BytesTransferred();

 	Test.Printf(_L("Bytes played = %d vs %d\n"),bytesPlayed, bytesToPlay);

 	CHECK_EQUAL(bytesToPlay,bytesPlayed);

 	TxSoundDevice.ResetBytesTransferred();

 	CHECK_EQUAL(TxSoundDevice.BytesTransferred(),0);

 	Test.Next(_L("Pause and resume when not playing"));

 	TxSoundDevice.Pause();

 	TxSoundDevice.Resume();

 	chunk.Close();

 	for (i=0;i<2;i++)

 		delete tPtr[i];

 	}

 LOCAL_C void TestBasicRecordFunctions()

 	{

 	TRequestStatus stat;

 	TInt length, r, i;

 	Test.Next(_L("Preparing to record..."));

 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = 2;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (RecordCapsBuf().iRates & (1<<i))

 			{

 			CHECK_NOERROR(r);				// Caps reports it is supported

 			break;

 			}

 		}

 	PrintConfig(RecordFormatBuf(),Test);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=3;

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	Test.Next(_L("Test for record overflow"));

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	RxSoundDevice.RecordData(stat,length);

 	User::WaitForRequest(stat);

 	TInt retOffset=stat.Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length>0);

 	r=RxSoundDevice.ReleaseBuffer(retOffset);

 	CHECK_NOERROR(r);

 	User::After(500000);			// Wait 1/2 second for data overflow.

 	RxSoundDevice.RecordData(stat,length);

 	User::WaitForRequest(stat);

 	retOffset=stat.Int();

 	CHECK(retOffset==KErrOverflow);

 	// Make sure we can issue a successful RecordData after recovering from overflow.

 	RxSoundDevice.RecordData(stat,length);

 	User::WaitForRequest(stat);

 	retOffset=stat.Int();

 	CHECK_POSITIVE(retOffset);

     r=RxSoundDevice.ReleaseBuffer(retOffset);

     CHECK_NOERROR(r);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	chunk.Close();

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-241

 	@SYMTestCaseDesc 		Play operation - playing all rates.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			1)	For each of the sample rates supported by the device, setup the audio configuration

 								on the playback channel for mono operation (i.e. 1 audio channel) and then setup

 								the buffer configuration so it contains multiple buffers. Using multiple simultaneous play requests,

 								play 4 seconds of continuous tone - with each individual play request consisting of 1/8th second of

 								tone. (Ensure the last request is marked with the KSndFlagLastSample flag).

 							2)	Repeat the above with the driver configured for stereo operation (i.e. 2 audio channels).

 	@SYMTestExpectedResults	1)	For each of the sample rates supported by the device, the driver should successfully play

 								4 seconds of tone, with no interruptions in the sound produced and with all requests

 								completing with KErrNone.

 							2)	For each of the sample rates supported by the device, the driver should successfully play

 								4 seconds of tone, with no interruptions in the sound produced and with all requests

 								completing with KErrNone.

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestPlayAllRates(TInt aNumChannels,TInt aNumSeconds)

 	{

 	TRequestStatus stat[2];

 	TPtr8* tPtr[2];

 	TInt i;

 	for (i=0;i<2;i++)

 		tPtr[i]=new TPtr8(NULL,0);

 	Test.Next(_L("Play all rates test"));

 	Test.Printf(_L("Number of channels %d, duration %d seconds\n"), aNumChannels, aNumSeconds);

 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	PlayFormatBuf().iChannels = aNumChannels;

 	TInt r=MakeSineTable(PlayFormatBuf());

 	CHECK_NOERROR(r);

 	TxSoundDevice.SetVolume(KSoundMaxVolume);

 	RChunk chunk;

 	TInt speed = 0;

 	while (speedTable[speed]>=0)

 		{

 		PlayFormatBuf().iRate = speedTable[speed++];

 		PlayFormatBuf().iChannels = aNumChannels;

 		// Set the play format.

 		Test.Printf(_L("Testing playback rate %d...\r\n"),RateInSamplesPerSecond(PlayFormatBuf().iRate));

 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 		if (r==KErrNotSupported)

 			{

 			Test.Printf(_L("Sample rate not supported\r\n"));

 			continue;

 			}

 		CHECK_NOERROR(r);

 		// Set the play buffer configuration, then read it back.

 		TInt bufSize=BytesPerSecond(PlayFormatBuf())/4; 	 								// Large enough to hold 1/4th second of data.

 		bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

 		TTestSharedChunkBufConfig bufferConfig;

 		bufferConfig.iNumBuffers=2;

 		bufferConfig.iBufferSizeInBytes=bufSize;

 		bufferConfig.iFlags=0;																// All buffers will be contiguous

 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 		r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 		CHECK_NOERROR(r);

 		TxSoundDevice.GetBufferConfig(bufferConfigBuf);

 		PrintBufferConf(bufferConfig,Test);

 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 		tPtr[0]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[0],0,bufSize);

 		tPtr[1]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[1],0,bufSize);

 		r=SetToneFrequency(440,PlayFormatBuf());

 		CHECK_NOERROR(r);

 		TxSoundDevice.ResetBytesTransferred();

 		CHECK_EQUAL(TxSoundDevice.BytesTransferred(),0);

 		// Issue a pair of play requests.

 		WriteTone(*tPtr[0],PlayFormatBuf());

 		TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

 		WriteTone(*tPtr[1],PlayFormatBuf());

 		TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

 		TInt remainingPlayCount = BytesPerSecond(PlayFormatBuf())*aNumSeconds/bufSize;

 		TInt bytesToPlay = remainingPlayCount*bufSize;

 		TInt bytesPlayed = 0;

 		TInt i;

 		TUint flags;

 		while(remainingPlayCount>2)

 			{

 			// Wait for either of the outstanding play requests to complete.

 			User::WaitForAnyRequest();

 			remainingPlayCount--;

 			// Work out which request this applies to.

 			for (i=0;i<2;i++)

 				{

 				if (stat[i]!=KRequestPending)

 					break;

 				}

 			CHECK(i<2);

 			CHECK_NOERROR(stat[i].Int());

 			WriteTone(*tPtr[i],PlayFormatBuf());

 			flags=(remainingPlayCount<=2)?KSndFlagLastSample:0;

 			TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],bufSize,flags);

 			}

 		// Last 2 play requests still outstanding.

 		User::WaitForRequest(stat[0]);

 		CHECK_NOERROR(stat[0].Int());

 		User::WaitForRequest(stat[1]);

 		CHECK_NOERROR(stat[1].Int());

 		Test.Printf(_L("Sample rate successful\r\n"));

 		bytesPlayed = TxSoundDevice.BytesTransferred();

 		CHECK_EQUAL(bytesToPlay,bytesPlayed);

 		chunk.Close();

 		}

 	for (i=0;i<2;i++)

 		delete tPtr[i];

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-254

 	@SYMTestCaseDesc 		Record operation - recording all rates.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			1)	For each of the sample rates supported by the device, setup the audio configuration on

 								the record channel for mono operation (i.e. 1 audio channel) and then setup the buffer

 								configuration so it contains multiple buffers. Using multiple simultaneous record

 								requests, record 4 seconds of audio data - with each individual record request being

 								for 1/8th second of data.

 							2)	Repeat the above with the driver configured for stereo operation (i.e. 2 audio channels).

 	@SYMTestExpectedResults	1)	For each of the sample rates supported by the device, the driver should successfully

 							record 4 seconds of data, with all requests completing with KErrNone.

 							2)	For each of the sample rates supported by the device, the driver should successfully

 							record 4 seconds of data, with all requests completing with KErrNone

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestRecordAllRates(TInt aNumChannels,TInt aNumSeconds)

 	{

 	TRequestStatus stat[2];

 	TInt length[2];

 	Test.Next(_L("Record all rate test"));

 	Test.Printf(_L("Number of channels %d, duration %d seconds\n"), aNumChannels, aNumSeconds);

 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RChunk chunk;

 	TInt speed = 0;

 	while (speedTable[speed]>=0)

 		{

 		RecordFormatBuf().iRate = speedTable[speed++];

 		RecordFormatBuf().iChannels = aNumChannels;

 		// Set the record format.

 		Test.Printf(_L("Testing record rate %d...\r\n"),RateInSamplesPerSecond(RecordFormatBuf().iRate));

 		TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (r==KErrNotSupported)

 			{

 			Test.Printf(_L("Sample rate not supported\r\n"));

 			continue;

 			}

 		CHECK_NOERROR(r);

 		// Set the record buffer configuration, then read it back.

 		TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 		bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 		TTestSharedChunkBufConfig bufferConfig;

 		bufferConfig.iNumBuffers=4;

 		bufferConfig.iBufferSizeInBytes=bufSize;

 		bufferConfig.iFlags=0;																// All buffers will be contiguous

 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 		r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 		CHECK_NOERROR(r);

 		RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 		PrintBufferConf(bufferConfig,Test);

 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 		TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*aNumSeconds/bufSize;

 		TInt bytesToRecord = remainingRecordCount*bufSize;

 		TInt bytesRecorded = 0;

 		// The driver rounds up the buffer size to the nearest page meaning the total duration

 		// to complete this test won't be exactly equal to 'aNumSeconds' anymore. Hence, the

 		// predicted time is no longer simply: aNumSeconds * 1000000.

 		TInt64 predictedTime = (bufSize * remainingRecordCount);

 		predictedTime*=1000000;

 		predictedTime+=BytesPerSecond(RecordFormatBuf())>>1;

 		predictedTime/=BytesPerSecond(RecordFormatBuf());

 		TTime starttime;

 		starttime.HomeTime();

 		// Issue a pair of record requests.

 		TInt vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

 		RxSoundDevice.SetVolume(vol);

 		RxSoundDevice.RecordData(stat[0],length[0]);

 		RxSoundDevice.RecordData(stat[1],length[1]);

 		TInt currentReq=0;

 		TInt retOffset;

 		do

 			{

 			// Wait for the next expected request to complete.

 			User::WaitForRequest(stat[currentReq]);

 			remainingRecordCount--;

 			retOffset=stat[currentReq].Int();

 			CHECK_POSITIVE(retOffset);

 			CHECK(length[currentReq]>0);

 			bytesRecorded += length[currentReq];

 			r=RxSoundDevice.ReleaseBuffer(retOffset);

 			CHECK_NOERROR(r);

 			CHECK_EQUAL(RxSoundDevice.Volume(),vol);

 			CHECK_EQUAL(RxSoundDevice.SetAudioFormat(RecordFormatBuf),KErrInUse);

 			vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

 			RxSoundDevice.SetVolume(vol);

 			// Don't issue any further record requests on the last two loop passes - to allow for the

 			// two record requests made before the loop started.

 			if (remainingRecordCount>=2)

 				RxSoundDevice.RecordData(stat[currentReq],length[currentReq]);

 			currentReq^=0x01;	// Toggle the current req. indicator

 			}

 		while(remainingRecordCount>0);

 		TTime endtime;

 		endtime.HomeTime();

 		TInt64 elapsedTime = endtime.Int64()-starttime.Int64();	// us

 		Test.Printf(_L("Recorded %d bytes in %d us\n"),bytesRecorded, I64LOW(elapsedTime));

 		if (elapsedTime < predictedTime)

 			{

 			Test.Printf(_L("**** FAIL: time travelling; record took less time than it could have done\n"));

 			// CHECK_NOERROR(1);

 			}

 		CHECK_EQUAL(bytesToRecord,bytesRecorded);

 		Test.Printf(_L("Sample rate successful\r\n"));

 		RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 		chunk.Close();

 		}

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-253

 	@SYMTestCaseDesc 		Record operation - altering the record level.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

 							so it contains multiple buffers. Using multiple simultaneous record requests, record 10

 							seconds of audio data - with each individual record request being for 1/8th second of data.

 							Each time a request completes, increase the record level slightly - starting at the minimum

 							and ending at maximum record level.

 	@SYMTestExpectedResults	The driver should successfully record 10 seconds of data - i.e. all requests should complete

 							with KErrNone.

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestRecordVolume(TInt aNumChannels,TInt aNumSeconds)

 	{

 	TRequestStatus stat[2];

 	TInt length[2];

 	TInt r, i;

 	Test.Next(_L("Preparing to test variable record levels..."));

 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = aNumChannels;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (RecordCapsBuf().iRates & (1<<i))

 			{

 			CHECK_NOERROR(r);				// Caps reports it is supported

 			break;

 			}

 		}

 	PrintConfig(RecordFormatBuf(),Test);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=8;

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	Test.Next(_L("Recording..."));

 	TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*aNumSeconds/bufSize;

 	TInt bytesToRecord = remainingRecordCount*bufSize;

 	TInt bytesRecorded = 0;

 	// Issue a pair of record requests.

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	RxSoundDevice.RecordData(stat[1],length[1]);

 	TInt currentReq=0;

 	TInt retOffset;

 	do

 		{

 		// Adjust the record level.

 		TInt vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

 		r=RxSoundDevice.SetVolume(vol);

 		CHECK_NOERROR(r);

 		// Wait for the next expected request to complete.

 		User::WaitForRequest(stat[currentReq]);

 		remainingRecordCount--;

 		retOffset=stat[currentReq].Int();

 		CHECK_POSITIVE(retOffset);

 		// Check the length recorded and update bytes recorded.

 		CHECK(length[currentReq]>0);

 		bytesRecorded += length[currentReq];

 		Test.Printf(_L("."));

 		// Read back the record level / check we can't reconfig while recording.

 		CHECK_EQUAL(RxSoundDevice.Volume(),vol);

 		CHECK_EQUAL(RxSoundDevice.SetAudioFormat(RecordFormatBuf),KErrInUse);

 		// Now release the buffer and issue another record request.

 		r=RxSoundDevice.ReleaseBuffer(retOffset);

 		CHECK_NOERROR(r);

 		// Don't issue any further record requests on the last two loop passes - to allow for the

 		// two record requests made before the loop started.

 		if (remainingRecordCount>=2)

 			RxSoundDevice.RecordData(stat[currentReq],length[currentReq]);

 		currentReq^=0x01;	// Toggle the current req. indicator

 		}

 	while(remainingRecordCount>0);

 	CHECK_EQUAL(bytesToRecord,bytesRecorded);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	Test.Printf(_L("\nBytes recorded = %d\r\n"),bytesRecorded);

 	chunk.Close();

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-245

 	@SYMTestCaseDesc 		Play operation - play cancellation.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

 							so it contains two buffers.

 							1)	Issue two simultaneous play requests, one from each buffer, each of 1/2 second of tone.

 								Wait for the first one to complete and issue a further play request from the same buffer.

 								Then immediately cancel all outstanding play requests (using CancelPlayData()).

 							2)	Issue two simultaneous play requests, one from each buffer, each of 1/2 second of tone.

 								Wait for the first one to complete and issue a further play request from the same buffer.

 								Then immediately cancel the 2nd (i.e. now active) play request (using Cancel()).

 	@SYMTestExpectedResults	1)	Both outstanding requests should complete, either with KErrNone or with KErrCancel.

 							2)	The second request should complete, either with KErrNone or with KErrCancel whereas the

 								third should complete only with KErrNone.

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestPlayCancel()

 	{

 	TRequestStatus stat[2];

 	TPtr8* tPtr[2];

 	TInt i, r;

 	for (i=0;i<2;i++)

 		tPtr[i]=new TPtr8(NULL,0);

 	Test.Next(_L("Test play cancellation"));

 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	PlayFormatBuf().iChannels = 2;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		// check record channel

 		PlayFormatBuf().iRate = (TSoundRate)i;

 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 		if (PlayCapsBuf().iRates & (1 << i))

 			{

 			CHECK_NOERROR(r);		// Caps reports it is supported

 			break;

 			}

 		}

 	PrintConfig(PlayFormatBuf(),Test);

 	r=MakeSineTable(PlayFormatBuf());

 	CHECK_NOERROR(r);

 	// Set the play buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(PlayFormatBuf())/2; 									// Large enough to hold 1/2 second of data.

 	bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=2;

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	TxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	tPtr[0]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[0],0,bufSize);

 	tPtr[1]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[1],0,bufSize);

 	Test.Next(_L("Test cancelling all outstanding requests"));

 	// Issue a pair of play requests.

 	r=SetToneFrequency(440,PlayFormatBuf());

 	CHECK_NOERROR(r);

 	WriteTone(*tPtr[0],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

 	WriteTone(*tPtr[1],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

 	// Wait for the 1st request to complete. Then, re-queue a further request but then

 	// immediately cancel both requests.

 	User::WaitForRequest(stat[0]);

 	CHECK_NOERROR(stat[0].Int());

 	WriteTone(*tPtr[0],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

 	TxSoundDevice.CancelPlayData();

 	User::WaitForRequest(stat[1]);

 	if (stat[1]==KErrNone)

 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(stat[1].Int(),KErrCancel);

 	User::WaitForRequest(stat[0]);

 	if (stat[0]==KErrNone)

 		Test.Printf(_L("Note: 3rd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(stat[0].Int(),KErrCancel);

 	Test.Next(_L("Test cancelling an individual requests"));

 	// Issue a further pair of play requests.

 	r=SetToneFrequency(440,PlayFormatBuf());

 	CHECK_NOERROR(r);

 	WriteTone(*tPtr[0],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

 	WriteTone(*tPtr[1],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize,0);

 	// Again, wait for the 1st request to complete. Then, re-queue a further request but then

 	// immediately cancel the 2nd request.

 	User::WaitForRequest(stat[0]);

 	CHECK_NOERROR(stat[0].Int());

 	WriteTone(*tPtr[0],PlayFormatBuf());

 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,KSndFlagLastSample);

 	TxSoundDevice.Cancel(stat[1]);

 	User::WaitForRequest(stat[1]);

 	if (stat[1]==KErrNone)

 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(stat[1].Int(),KErrCancel);

 	User::WaitForRequest(stat[0]);

 	CHECK_NOERROR(stat[0].Int());

 	chunk.Close();

 	Test.Printf(_L("Cancel play test completed successful\r\n"));

 	for (i=0;i<2;i++)

 		delete tPtr[i];

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-259

 	@SYMTestCaseDesc 		Record operation - record cancellation.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

 							so it contains multiple buffers.

 							1)	Issue two simultaneous record requests requests, each for 1/2 second of data. Wait for

 								the first one to complete and issue a further record request. Then immediately cancel all

 								outstanding record requests (using CancelRecordData()).

 							2)	Issue two simultaneous record requests, each for 1/2 second of data. Wait for the first

 								one to complete and issue a further record request. Then immediately cancel the 2nd (i.e.

 								now active) record request (using Cancel()).

 	@SYMTestExpectedResults	1)	Both outstanding requests should complete, either with KErrNone or with KErrCancel.

 							2)	The second requests should complete, either with KErrNone or with KErrCancel whereas the

 								third should complete only with KErrNone.

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestRecordCancel()

 	{

 	TRequestStatus stat[2];

 	TInt length[2];

 	TPtr8* tPtr[2];

 	TInt i, r;

 	for (i=0;i<2;i++)

 		tPtr[i]=new TPtr8(NULL,0);

 	Test.Next(_L("Test record cancellation"));

 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = 2;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (RecordCapsBuf().iRates & (1<<i))

 			{

 			CHECK_NOERROR(r);				// Caps reports it is supported

 			break;

 			}

 		}

 	PrintConfig(RecordFormatBuf(),Test);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=3;

 	bufferConfig.iBufferSizeInBytes=BytesPerSecond(RecordFormatBuf())/2; // Large enough to hold 1/2 second of data.

 	bufferConfig.iBufferSizeInBytes=ValidBufferSize(bufferConfig.iBufferSizeInBytes,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());		// Keep the buffer length valid for driver.

 	bufferConfig.iFlags=0;		// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	Test.Next(_L("Test cancelling all outstanding requests"));

 	// Issue a pair of record requests.

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	RxSoundDevice.RecordData(stat[1],length[1]);

 	// Wait for the 1st request to complete. Then, re-queue a further request but then

 	// immediately cancel both requests.

 	TInt retOffset;

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length[0]>0);

 	r=RxSoundDevice.ReleaseBuffer(retOffset);

 	CHECK_NOERROR(r);

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	RxSoundDevice.CancelRecordData();

 	User::WaitForRequest(stat[1]);

 	retOffset=stat[1].Int();

 	if (retOffset>=0)

 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(retOffset,KErrCancel);

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	if (retOffset>=0)

 		Test.Printf(_L("Note: 3rd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(retOffset,KErrCancel);

 	Test.Next(_L("Test cancelling an individual requests"));

 	// Issue a further pair of record requests.

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	RxSoundDevice.RecordData(stat[1],length[1]);

 	// Again, wait for the 1st request to complete. Then, re-queue a further request but then

 	// immediately cancel the 2nd request.

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length[0]>0);

 	r=RxSoundDevice.ReleaseBuffer(retOffset);

 	CHECK_NOERROR(r);

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	RxSoundDevice.Cancel(stat[1]);

 	User::WaitForRequest(stat[1]);

 	retOffset=stat[1].Int();

 	if (retOffset>=0)

 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

 	else

 		CHECK_EQUAL(retOffset,KErrCancel);

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length[0]>0);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	chunk.Close();

 	Test.Printf(_L("Cancel record test completed successful\r\n"));

 	for (i=0;i<2;i++)

 		delete tPtr[i];

 	}

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-262

 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming before playback has commenced.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration.

 							1)	Attempt to resume recording before recording has been started.

 							2)	Attempt to pause recording before recording has been started.

 	@SYMTestExpectedResults	1)	The resume request should complete with KErrNotReady.

 							2)	The pause request should complete with KErrNotReady.

 	@SYMREQ					PREQ1073.4

 */

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-263

 	@SYMTestCaseDesc 		Record pause / resume - pausing and resuming while recording is in progress.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

 							so it contains multiple buffers. For the audio configuration selected, calculate the total

 							number of bytes expected to be transferred in order record 4 seconds of data. Using multiple

 							simultaneous record requests, record 4 seconds of audio data - with each individual record

 							request being for 1/8th second of data. Increment a count of actual total bytes transferred

 							by examining the count of bytes stored in the buffer for each request as it completes.

 							1) After 10 requests have completed, pause transfer for 1 second, then resume it. If pausing

 							causes a record request to complete with a shorter than requested length then reduce the

 							count of expected total bytes transferred.

 							2) Repeat step 1 when 20 requests have completed.

 							3) Once transfer has completed, compare the counts of expected and actual total bytes

 							transferred.

 	@SYMTestExpectedResults	1)	The pause and resume requests should both complete with KErrNone.

 							2)	The pause and resume requests should both complete with KErrNone.

 							3)	The counts should be equal.

 	@SYMREQ					PREQ1073.4

 */

 LOCAL_C void TestRecordPauseResume(TUint aChannels)

 	{

 	TRequestStatus stat[2];

 	TInt length[2];

 	Test.Next(_L("Test record pause and resume"));

 	RecordFormatBuf().iRate = ESoundRate44100Hz;

 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = aChannels;

 	PrintConfig(RecordFormatBuf(),Test);

 	TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 	CHECK_NOERROR(r);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=8;

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	Test.Printf(_L("Resume when not recording\r\n"));

 	r=RxSoundDevice.Resume();

 	CHECK(r==KErrNotReady)

 	Test.Printf(_L("Pause when not recording\r\n"));

 	r=RxSoundDevice.Pause();

 	CHECK(r==KErrNotReady)

 	// Record for 4 seconds

 	Test.Printf(_L("Record...\r\n"));

 	TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*4/bufSize;

 	TInt bytesToRecord = remainingRecordCount*bufSize;

 	TInt bytesRecorded = 0;

 	// Issue a pair of record requests.

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	length[0] = -42;

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	length[1] = -42;

 	RxSoundDevice.RecordData(stat[1],length[1]);

 	TInt currentReq=0;

 	TInt lcount = 0;

 	TInt retOffset;

 	do

 		{

 		// Do a pause / resume on 10th and 20th loop passes.

 		if (lcount && !(lcount%10))

 			{

 			// Do a pause/resume

 			Test.Printf(_L("Pause 1 second\r\n"));

 			r=RxSoundDevice.Pause();

 			CHECK_NOERROR(r);

 			// Pausing record may result in the driver completing with a buffer not completely full. This isn't an error. Otherwise, all outstanding

 			// requests should complete with KErrCancel. Wait for the 1st outstanding request to complete.

 			User::WaitForRequest(stat[currentReq]);

 			retOffset=stat[currentReq].Int();

 			if (retOffset>=0)

 				{

 				// Partially filled buffer. We need to adjust the bytes expected when an incomplete buffer arrives.

 				remainingRecordCount--;

 				CHECK_POSITIVE(length[currentReq]);

 				CHECK(length[currentReq]<=bufSize);

 				bytesRecorded += length[currentReq];

 				if (length[currentReq]<bufSize)

 					bytesToRecord-=(bufSize-length[currentReq]);

 				Test.Printf(_L("1st outstanding req partially completed(len=%d)\r\n"),length[currentReq]);

 				r=RxSoundDevice.ReleaseBuffer(retOffset); // Release the buffer ready for resuming

 				CHECK_NOERROR(r);

 				}

 			else

 				{

 				CHECK(retOffset==KErrCancel);

 				Test.Printf(_L("1st outstanding req cancelled\r\n"));

 				}

 			currentReq^=0x01;	// Toggle the current req. indicator

 			// Wait for the 2nd outstanding request to complete

 			User::WaitForRequest(stat[currentReq]);

 			retOffset=stat[currentReq].Int();

 			CHECK(retOffset==KErrCancel);

 			Test.Printf(_L("2nd outstanding req cancelled\r\n"));

 			// Idle for 1 second, resume and then re-issue a pair of record requests.

 			User::After(1000000);

 			Test.Printf(_L("Resume\r\n"));

 			r=RxSoundDevice.Resume();

 			CHECK_NOERROR(r);

 			RxSoundDevice.RecordData(stat[0],length[0]);

 			RxSoundDevice.RecordData(stat[1],length[1]);

 			currentReq=0;

 			}

 		// Wait for the next expected request to complete.

 		User::WaitForRequest(stat[currentReq]);

 		remainingRecordCount--;

 		retOffset=stat[currentReq].Int();

 		CHECK_POSITIVE(retOffset);

 		CHECK(length[currentReq]>0);

 		bytesRecorded += length[currentReq];

 		// Now release the buffer and issue another record request

 		r=RxSoundDevice.ReleaseBuffer(retOffset);

 		CHECK_NOERROR(r);

 		// Don't issue any further record requests on the last two loop passes - to allow for the

 		// two record requests made before the loop started.

 		if (remainingRecordCount>=2)

 			RxSoundDevice.RecordData(stat[currentReq],length[currentReq]);

 		lcount++;

 		currentReq^=0x01;	// Toggle the current req. indicator

 		}

 	while(remainingRecordCount>0);

 	CHECK_EQUAL(bytesToRecord,bytesRecorded);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	Test.Printf(_L("Record pause/resume successful\r\n"));

 	Test.Next(_L("Test record pause alone"));

 	// Issue a single record request, wait for it to complete and then release it.

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length[0]==bufSize);

 	r=RxSoundDevice.ReleaseBuffer(retOffset);

 	CHECK_NOERROR(r);

 	// Without issuing another record request, wait for a duration equal to one record buffer, then pause.

 	User::After(150000);	// Wait a bit longer than 1 buffer's worth (125000 is 1/8 second).

 	Test.Printf(_L("Pause\r\n"));

 	r=RxSoundDevice.Pause();

 	CHECK_NOERROR(r);

 	// Check that there is at least 1 buffer's worth of record data available

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	CHECK_POSITIVE(retOffset);

 	CHECK(length[0]==bufSize);

 	Test.Printf(_L("1st req completed successfully\r\n"));

 	r=RxSoundDevice.ReleaseBuffer(retOffset);

 	CHECK_NOERROR(r);

 	// There's probably also a partially filled buffer

 	RxSoundDevice.RecordData(stat[0],length[0]);

 	User::WaitForRequest(stat[0]);

 	retOffset=stat[0].Int();

 	if (retOffset>=0)

 		{

 		// Partially filled buffer.

 		CHECK(length[0]>0);

 		CHECK(length[0] <= bufSize);

 		Test.Printf(_L("2nd req partially completed(len=%d)\r\n"),length[0]);

 		r=RxSoundDevice.ReleaseBuffer(retOffset);

 		CHECK_NOERROR(r);

 		}

 	else

 		{

 		CHECK(retOffset==KErrCancel);

 		Test.Printf(_L("2nd req cancelled\r\n"));

 		}

 	for(;;)

 		{

 		// Read all buffers until driver is empty. The RecordData call after that should immediately return with KErrCancel

 		Test.Printf(_L("Draining driver\r\n"));

 		RxSoundDevice.RecordData(stat[0],length[0]);

 		User::WaitForRequest(stat[0]);

 		retOffset=stat[0].Int();

 		if(retOffset==KErrCancel)

 			{

 			break;

 			}

 		CHECK_NOERROR(retOffset);

 		}

 	Test.Printf(_L("Driver empty\r\n"));

 	r=RxSoundDevice.Resume();			// Don't leave it in paused state.

 	CHECK_NOERROR(r);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	Test.Printf(_L("Record pause successful\r\n"));

 	chunk.Close();

 	}

 template <class T>

 class RQueue

     {

 public:

     RQueue() 

         : iArray() 

         { }

     void Close() 

         { 

         iArray.Close(); 

         }

     TInt Count() const 

         { 

         return iArray.Count(); 

         }

     void PushL(const T &aItem) 

         {

         iArray.AppendL(aItem); 

         }

     T PopL()

         {

         if(iArray.Count() == 0)

             {

             User::Leave(KErrUnderflow);

             }

         const T ret = iArray[0];

         iArray.Remove(0);

         return ret;

         }

 private:

     RArray<T> iArray;

     };

 /**	@SYMTestCaseID 			PBASE-T_SOUND2-248

 	@SYMTestCaseDesc 		Play operation - simultaneous play and record on the same device, using a common shared chunk.

 	@SYMTestPriority 		Critical

 	@SYMTestActions			Setup the audio configuration on the record channel and setup an identical audio

 							configuration on the playback channel. On the record channel, create a shared chunk

 							(i.e. using SetBufferChunkCreate()) with a buffer configuration containing multiple buffers.

 							Open the same shared chunk on the playback channel (i.e. using SetBufferChunkOpen()).

 							Set the volume to maximum level in both channels. Record 10 seconds of audio data - with

 							each individual record request being for 1/8th second of data. As soon as each record request

 							completes, issue a corresponding request on the playback channel to playback the

 							1/8th second of data recorded. Only release each buffer for further recording once its

 							contents have been played back. Continue until 10 seconds of audio data has been both

 							recorded and played back. (Ensure the last play request is marked with the

 							KSndFlagLastSample flag).

 	@SYMTestExpectedResults	The driver should successfully record and play 10 seconds of data - with all requests

 							completing with KErrNone.

 	@SYMREQ					PREQ1073.4

 */

 void TestSimultaneousPlayRecord()

 	{

 	Test.Next(_L("Preparing to record/play simultaneously..."));

 	TInt r = KErrNone;

 	TInt i;

 	// Setup the same sound configuration for both - record and play channels

 	if (RecordCapsBuf().iEncodings & KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = 2;

 	PlayFormatBuf().iChannels = 2;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		// check record channel

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (RecordCapsBuf().iRates & (1 << i))

 			{

 			CHECK_NOERROR(r);		// Caps reports it is supported

 			// ..and try the same bitrate for playback

 			PlayFormatBuf().iRate = (TSoundRate)i;

 			r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 			if (PlayCapsBuf().iRates & (1 << i))

 				{

 				CHECK_NOERROR(r);		// Caps reports it is supported

 				break;

 				}

 			}

 		}

 	// both channels are set at this point, continue

 	PrintConfig(RecordFormatBuf(),Test);

 	PrintConfig(PlayFormatBuf(),Test);

 	// Set the volume level in both channels

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	TxSoundDevice.SetVolume(KSoundMaxVolume - 10);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=7+7;														// Must be able to use less than this

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	PrintBufferConf(bufferConfig,Test);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	// Assign the same chunk to the play channel.

 	r=TxSoundDevice.SetBufferChunkOpen(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Starting transfer..."));

 	TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*10/bufSize; // 10 seconds

 	TInt remainingPlayCount = remainingRecordCount;

 	TInt bytesToTransfer = remainingRecordCount*bufSize;

 	TInt bytesRecorded = 0;

 	TInt bytesPlayed = 0;

 	TRequestStatus stat[3]; 	// 1 record + 2 play request statuses

 	TInt length;

 	TInt activePlayOffset[2];	// To keep track of the buffer offset for each active play request.

 	RQueue<TInt> playQueue; // A list containing the offsets for any buffer which is waiting to be played.

 	// Issue three record requests and wait for them to complete.

 	TInt retOffset;

 	for (i=0 ; i<3 ; i++)

 		{

 		RxSoundDevice.RecordData(stat[2],length);

 		User::WaitForRequest(stat[2]);

 		retOffset=stat[2].Int();

 //		Test.Printf(_L("RECORD(%d)-Buf %d\r\n"),i,retOffset);

 		CHECK_POSITIVE(retOffset);

 		CHECK(length==bufSize);

 		bytesRecorded += length;

 		playQueue.PushL(retOffset);

 		remainingRecordCount--;

 		Test.Printf(_L("."));

 		}

 	// Start playing first two buffers

 	TUint flags=0;

 	activePlayOffset[0]=playQueue.PopL();

 	TxSoundDevice.PlayData(stat[0],activePlayOffset[0],bufSize,flags);

 	activePlayOffset[1]=playQueue.PopL();

 	TxSoundDevice.PlayData(stat[1],activePlayOffset[1],bufSize,flags);

 	// Now queue the next record request.

 	RxSoundDevice.RecordData(stat[2],length);

 	do

 		{

 		// Wait for the next request to complete.

 		User::WaitForAnyRequest();

 		// Work out which request this applies to.

 		for (i=0;i<3;i++)

 			{

 			if (stat[i]!=KRequestPending)

 				break;

 			}

 		CHECK(i<3);

 		if (i==2)

 			{

 			// It is the record request that has completed

 			remainingRecordCount--;

 			retOffset=stat[2].Int();

 //			Test.Printf(_L("RECORD(%d)-Buf %d\r\n"),remainingRecordCount,retOffset);

 			CHECK_POSITIVE(retOffset);

 			CHECK(length==bufSize);

 			bytesRecorded += length;

 			Test.Printf(_L("."));

 			// Add the buffer to playQueue

 			playQueue.PushL(retOffset);

 			// If we haven't recorded enough data yet then record some more.

 			if (remainingRecordCount>0)

 				RxSoundDevice.RecordData(stat[2],length);

 			else

 				{

 				Test.Printf(_L("***Disabling stat[2]\r\n"));

 				stat[2]=KRequestPending;

 				}

 			}

 		else

 			{

 			// Its one of the play requests that have completed

 			if(stat[i].Int() >= 0)

 				{

 				// release the buffer.

 //				Test.Printf(_L("PLAY(%d) i%d CompBuf %d\r\n"),remainingPlayCount-1,i,activePlayOffset[i]);

 				r=RxSoundDevice.ReleaseBuffer(activePlayOffset[i]);

 				CHECK_NOERROR(r);

 				Test.Printf(_L("*"));

 				}

 			else

 				{

 				// Play failed - but we ignore underflow because it often happens on WDP roms.

 				CHECK(stat[i].Int() == KErrUnderflow);

 				Test.Printf(_L("U"));

 				}

 			remainingPlayCount--;

 			bytesPlayed += bufSize;

 			// If there are buffers available then issue a further play request and update the 'next to play' list.

 			if (playQueue.Count() != 0)

 				{

 				activePlayOffset[i]=playQueue.PopL();

 //				Test.Printf(_L("PLAY(%d) i%d NextBuf%d\r\n"),remainingPlayCount,i,activePlayOffset[i]);

 				flags=(remainingPlayCount<=2)?KSndFlagLastSample:0;

 				TxSoundDevice.PlayData(stat[i],activePlayOffset[i],bufSize,flags);

 				}

 			else

 				{

 				Test.Printf(_L("***Disabling stat[%d]\r\n"), i, stat[i].Int());

 				stat[i]=KRequestPending;

 				}

 			}

 		}

 	while (remainingRecordCount>0 || remainingPlayCount>0);

 	playQueue.Close();

 	CHECK_EQUAL(bytesToTransfer,bytesRecorded);

 	CHECK_EQUAL(bytesToTransfer,bytesPlayed);

 	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

 	chunk.Close();

 	Test.Printf(_L("\nSimultaneous test ends\r\n"));

 	return;

 	}

 void TestSpeed()

 	{

 	Test.Next(_L("Preparing to measure record/playback speed..."));

 	TInt r = KErrNone;

 	TInt i;

 	// Setup the same sound configuration for both - record and play channels

 	if (RecordCapsBuf().iEncodings & KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = 2;

 	PlayFormatBuf().iChannels = 2;

 	// find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		// check record channel

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		if (RecordCapsBuf().iRates & (1 << i))

 			{

 			CHECK_NOERROR(r);		// Caps reports it is supported

 			// ..and try the same bitrate for playback

 			PlayFormatBuf().iRate = (TSoundRate)i;

 			r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 			if (PlayCapsBuf().iRates & (1 << i))

 				{

 				CHECK_NOERROR(r);		// Caps reports it is supported

 				break;

 				}

 			}

 		}

 	// both channels are set at this point, continue

 	PrintConfig(RecordFormatBuf(),Test);

 	PrintConfig(PlayFormatBuf(),Test);

 	// Set the volume level in both channels

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	TxSoundDevice.SetVolume(KSoundMaxVolume - 10);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize=BytesPerSecond(RecordFormatBuf())/8; 									// Large enough to hold 1/8th second of data.

 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=7+7;															// Must be able to use less than this

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;																// All buffers will be contiguous

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	PrintBufferConf(bufferConfig,Test);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	// Assign the same chunk to the play channel.

 	r=TxSoundDevice.SetBufferChunkOpen(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Starting recording speed test..."));

 	TInt length;

 	// Recording speed test

 	TTime preTime, postTime;

 	preTime.UniversalTime();

 	for(i=0; i<100; ++i)

 		{

 		TRequestStatus s;

 		length = -1;

 		TTime preBufTime, postBufTime;

 		preBufTime.UniversalTime();

 		RxSoundDevice.RecordData(s, length);

 		User::WaitForRequest(s);

 		postBufTime.UniversalTime();

 		TTimeIntervalMicroSeconds elapsedBufTime = postBufTime.MicroSecondsFrom(preBufTime);

 		Test.Printf(_L("\tElapsed buf (%d/100) recording time %d\n"), i, elapsedBufTime.Int64());

 		CHECK(s.Int() >= 0);

 		CHECK(RxSoundDevice.ReleaseBuffer(s.Int()) == KErrNone);

 		CHECK(length == bufSize);

 		}

 	postTime.UniversalTime();

 	TTimeIntervalMicroSeconds elapsedRecordingTime = postTime.MicroSecondsFrom(preTime);

 	Test.Printf(_L("Elapsed recording time %d\n"), elapsedRecordingTime.Int64());

 	Test.Printf(_L("Record timing done\n"));

 	//

 	// Playback test

 	//

 	TxSoundDevice.CancelPlayData();

 	struct RequestInfo {

 		TRequestStatus s_m;

 		TUint bufOffset_m;

 		};

 	RequestInfo requestA;

 	RequestInfo requestB;

 	// Get two buffers for playback speed test

 	RxSoundDevice.RecordData(requestA.s_m, length);

 	User::WaitForRequest(requestA.s_m);

 	CHECK(requestA.s_m.Int() >= 0);

 	requestA.bufOffset_m = requestA.s_m.Int();

     RxSoundDevice.RecordData(requestB.s_m, length);

     User::WaitForRequest(requestB.s_m);

     CHECK(requestB.s_m.Int() >= 0);

     requestB.bufOffset_m = requestB.s_m.Int();

     Test.Printf(_L("buf offsets %d %d\n"), requestA.bufOffset_m, requestB.bufOffset_m);

 	RequestInfo *prevRequest = &requestA;

 	RequestInfo *currRequest = &requestB;

 	// Issue initial play request

 	TxSoundDevice.PlayData(prevRequest->s_m, prevRequest->bufOffset_m, bufSize);

 	preTime.UniversalTime();

 	for(i=0; i<100; ++i)

 		{

 		// Issue new request so we do not underflow....

 		TxSoundDevice.PlayData(currRequest->s_m, currRequest->bufOffset_m, bufSize, (i==99)?(KSndFlagLastSample) : (0));

 		// Wait for previous request to complete

 		TTime preBufTime, postBufTime;

 		preBufTime.UniversalTime();

 		User::WaitForRequest(prevRequest->s_m);

 		CHECK_NOERROR(prevRequest->s_m.Int());

 		postBufTime.UniversalTime();

 		TTimeIntervalMicroSeconds elapsedBufTime = postBufTime.MicroSecondsFrom(preBufTime);

 		Test.Printf(_L("\tElapsed buf (%d/100) playback time %d\n"), i, elapsedBufTime.Int64());

 		// Swap previous and current requests

 		RequestInfo *p = prevRequest;

 		prevRequest = currRequest;

 		currRequest = p;

 		}

 	postTime.UniversalTime();

 	TTimeIntervalMicroSeconds elapsedPlaybackTime = postTime.MicroSecondsFrom(preTime);

     Test.Printf(_L("Elapsed playback time  = %d us\n"), elapsedPlaybackTime.Int64());

     Test.Printf(_L("Elapsed recording time = %d us\n"), elapsedRecordingTime.Int64());

 	double play = (double) elapsedPlaybackTime.Int64();

 	double record = (double) elapsedRecordingTime.Int64();

 	Test.Printf(_L("difference %f%%\n"), (play*100)/record);

 	User::WaitForRequest(prevRequest->s_m);

 	CHECK_NOERROR(prevRequest->s_m.Int());

     // Free the two buffers

     CHECK(RxSoundDevice.ReleaseBuffer(requestA.bufOffset_m) == KErrNone);

     CHECK(RxSoundDevice.ReleaseBuffer(requestB.bufOffset_m) == KErrNone);

 	Test.Printf(_L("Playback done\n"));

     TxSoundDevice.CancelPlayData();

     RxSoundDevice.CancelPlayData();

 	chunk.Close();

 	return;		

 }

 #ifdef __WINS__

 void TestDefectDTWMM00678()

 {

 	// DTW-MM00678  RSoundSc::RecordData() returns recorded length > allocated buffer size 

     TRequestStatus status[3];

     TInt length[3];

 	Test.Next(_L("DTW-MM00678  RSoundSc::RecordData() returns recorded length > allocated buffer size"));

 	// Make sure recording is not in progress

 	RxSoundDevice.CancelRecordData();

 	TInt r = KErrNone;

 	TInt i;

 	// Setup the same sound configuration for both - record and play channels

 	if (RecordCapsBuf().iEncodings & KSoundEncoding16BitPCM)

 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 	RecordFormatBuf().iChannels = 2;

 	// Find first supported rate and set the the audio configuration to use it

 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

 		{

 		// check record channel

 		RecordFormatBuf().iRate = (TSoundRate)i;

 		if (RecordCapsBuf().iRates & (1 << i))

 			{

 			// Caps reports it is supported

 			r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 			CHECK_NOERROR(r);

 			break;

 			}

 		}

 	// Check we found/set a valid format

 	CHECK(i <= ESoundRate48000Hz);

 	// Set recording format

 	PrintConfig(RecordFormatBuf(),Test);

 	// Set the volume level

 	RxSoundDevice.SetVolume(KSoundMaxVolume);

 	// Set the record buffer configuration, then read it back.

 	RChunk chunk;

 	TInt bufSize = 64 * 1024; // The defect is seen, on windows, when the buffer size is 64k and the LDD does 2x 32k transfers per buffer

 	TTestSharedChunkBufConfig bufferConfig;

 	bufferConfig.iNumBuffers=7;		

 	bufferConfig.iBufferSizeInBytes=bufSize;

 	bufferConfig.iFlags=0;

 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 	CHECK_NOERROR(r);

 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 	PrintBufferConf(bufferConfig,Test);

 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 	// Calculate time required to fill a single 64k byte buffer

  	TUint32 durationOneBufferMsec = (1000 * bufSize) / BytesPerSecond(RecordFormatBuf());

     Test.Printf(_L("durationOneBufferMsec %d\n"), durationOneBufferMsec);

 	// Start recording....

     Test.Printf(_L("Issue 3 RecordData requests then wait to pause during second internal 32k internal transfers of the second buffer...\n"));

 	for(i=0; i<3; ++i)

 		{

 	    RxSoundDevice.RecordData(status[i], length[i]);

 		}

 	// Wait for 1 3/4 64k buffers. In  other words, wait for 3.75x32k byte internal transfers so we pause during the second transfer of the second buffer

  	User::After(durationOneBufferMsec *1000 * (1 + 3/4) );

     CHECK_NOERROR(RxSoundDevice.Pause());

     Test.Printf(_L("Paused\n"));

 	for(i=0; i<3; ++i)

 		{

 		User::WaitForRequest(status[i]);

 		Test.Printf(_L("status[%d].Int() = %d\n"), i, status[i].Int());

 		Test.Printf(_L("length[%d] = %d\n"), i, length[i]);

 		}

 	bool testValid = true;

 	if((status[0].Int() < 0) || (length[0] != bufSize))

 		{

 		testValid = false;

 		Test.Printf(_L("Test invalid because pause hit first request\n"));

 		}

 	if(testValid && (status[1].Int() == KErrCancel))

 		{

 		testValid = false;

 		Test.Printf(_L("Test invalid because pause hit before second request started\n"));

 		}

 	if(testValid && (status[2].Int() != KErrCancel))

 		{

 		testValid = false;

 		Test.Printf(_L("Test invalid because pause missed all requests\n"));

 		}

 	if(testValid)

 		{

 		Test.Printf(_L("Appear to have issued pause at the correct time, check results\n"));

 		// First request should have completed with a full buffer of data

 		CHECK(status[0].Int() >= 0);

     	CHECK(length[0] == bufSize);

 		// second request should have been truncated

 		CHECK(status[1].Int() >= 0);

    		CHECK(length[1] < bufSize);

 		// Last request should have been cancelled.

 		CHECK(status[2].Int() == KErrCancel);

 		}

 	Test.Printf(_L("DTW-MM00678 test done\r\n"));

     //CHECK_NOERROR(RxSoundDevice.Resume());

     // Make sure recording is not in progress

 	RxSoundDevice.CancelRecordData();

 	TxSoundDevice.CancelPlayData();

 	chunk.Close();

 	return;

 	}

 #endif

 LOCAL_C void TestUnloadDrivers()

 	{

 	TInt r=User::FreeLogicalDevice(KDevSoundScName);

 	Test.Printf(_L("Unloading %S.LDD - %d\r\n"),&KDevSoundScName,r);

 	CHECK_NOERROR(r);

 	TName pddName(KDevSoundScName);

 	_LIT(KPddWildcardExtension,".*");

 	pddName.Append(KPddWildcardExtension);

 	TFindPhysicalDevice findPD(pddName);

 	TFullName findResult;

 	r=findPD.Next(findResult);

 	while (r==KErrNone)

 		{

 		r=User::FreePhysicalDevice(findResult);

 		Test.Printf(_L("Unloading %S.PDD - %d\r\n"),&findResult,r);

 		CHECK_NOERROR(r);

 		findPD.Find(pddName); // Reset the find handle now that we have deleted something from the container.

 		r=findPD.Next(findResult);

 		}

 	}

 void TestTimePlayed()

 	{

 	TTimeIntervalMicroSecondsBuf timeIntervalBuf;

 	// Don't try to do the tests if TimePlayed() is not supported

 	TInt r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 	if (r == KErrNotSupported)

 		{

 		Test.Printf(_L("TimePlayed() is not supported, skipping tests\n"));

 		return;

 		}

 	CHECK_NOERROR(r);

 	TInt rate;

 	// Find first supported rate and set the the audio configuration to use it

 	for (rate = 0; rate <= ESoundRate48000Hz; ++rate)

 		{

 		if (PlayCapsBuf().iRates & (1 << rate))

 			{

 			break;

 			}

 		}

 	// Test mono and Stereo

 	for (TInt channels=1; channels<=2; ++channels)

 	{

 		TRequestStatus stat[2];

 		Test.Next(_L("Preparing to play..."));

 		if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 			PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 		PlayFormatBuf().iRate = (TSoundRate) rate;

 		PlayFormatBuf().iChannels = channels;

 		PrintConfig(PlayFormatBuf(),Test);

 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 		CHECK_NOERROR(r);

 		// Set the play buffer configuration, then read it back.

 		RChunk chunk;

 		TInt bufSize=BytesPerSecond(PlayFormatBuf()); 									// Large enough to hold 1 second of data.

 		bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

 		TTestSharedChunkBufConfig bufferConfig;

 		bufferConfig.iNumBuffers=2;

 		bufferConfig.iBufferSizeInBytes=bufSize;

 		bufferConfig.iFlags=0;		// All buffers will be contiguous

 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 		r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 		CHECK_NOERROR(r);

 		TxSoundDevice.GetBufferConfig(bufferConfigBuf);

 		PrintBufferConf(bufferConfig,Test);

 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 		TPtr8* tPtr[2];

 		TInt i;

 		for (i=0;i<2;i++)

 			tPtr[i]=new TPtr8(chunk.Base()+bufferConfig.iBufferOffsetList[i],bufSize);

 		r=MakeSineTable(PlayFormatBuf());

 		CHECK_NOERROR(r);

 		r=SetToneFrequency(440,PlayFormatBuf());

 		CHECK_NOERROR(r);

 		WriteTone(*tPtr[0],PlayFormatBuf());

 		WriteTone(*tPtr[1],PlayFormatBuf());

 		// set up a timer to interrogate time played

 		TRequestStatus timerStat;

 		RTimer timer;

 		timer.CreateLocal();

 		TTimeIntervalMicroSeconds32 timerInterval(50000);

 		TInt64 currentTime, previousTime;

 		Test.Next(_L("Time Played..."));

 		currentTime = previousTime = MAKE_TINT64(0,0);

 		TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

 		TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize,KSndFlagLastSample);

 		// check requests are pending

 		CHECK_EQUAL(stat[0].Int(),KRequestPending);

 		CHECK_EQUAL(stat[1].Int(),KRequestPending);

 		// check time recorded is not supported for play channel

 		CHECK(TxSoundDevice.TimeRecorded(timeIntervalBuf)==KErrNotSupported);

 		timer.After(timerStat,timerInterval);

 		// first buffer

 		while (stat[0] == KRequestPending)

 			{

 			User::WaitForRequest(stat[0],timerStat);

 			Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 		r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 		CHECK_EQUAL(stat[0].Int(),KErrNone);

 		timer.After(timerStat,timerInterval);

 		// second buffer

 		while (stat[1] == KRequestPending)

 			{

 			User::WaitForRequest(stat[1],timerStat);

 			Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			if (stat[1] == KRequestPending) // still playing

 				{

 				CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 		r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(timeIntervalBuf().Int64()),I64LOW(timeIntervalBuf().Int64()));

 		CHECK_EQUAL(stat[1].Int(),KErrNone);

 		//

 		// Time Played with pause

 		//

 		Test.Next(_L("Time Played with pause..."));

 		TTimeIntervalMicroSeconds32 pauseInterval(2000000);

 		TBool paused = EFalse;

 		currentTime = previousTime = MAKE_TINT64(0,0);

 		timer.Cancel();

 		TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

 		TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize,KSndFlagLastSample);

 		// check requests are pending

 		CHECK_EQUAL(stat[0].Int(),KRequestPending);

 		CHECK_EQUAL(stat[1].Int(),KRequestPending);

 		// check time recorded is not supported for play channel

 		CHECK(TxSoundDevice.TimeRecorded(timeIntervalBuf)==KErrNotSupported);

 		timer.After(timerStat,timerInterval);

 		// first buffer

 		while (stat[0] == KRequestPending)

 			{

 			User::WaitForRequest(stat[0],timerStat);

 			Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 			// Pause and resume ...

 			if (paused == EFalse && I64LOW(currentTime) > 500000)

 				{

 				paused = ETrue;

 				TxSoundDevice.Pause();

 				r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 				CHECK_NOERROR(r);

 				TInt64 pausedTime1 = timeIntervalBuf().Int64();

 				Test.Printf(_L("Paused time_high %d, time_low %d\n"),I64HIGH(pausedTime1),I64LOW(pausedTime1));

 				User::After(pauseInterval);

 				r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 				CHECK_NOERROR(r);

 				TInt64 pausedTime2 = timeIntervalBuf().Int64();

 				Test.Printf(_L("Resumed time_high %d, time_low %d\n"),I64HIGH(pausedTime2),I64LOW(pausedTime2));

 				//CHECK(pausedTime1 == pausedTime2);

 				TxSoundDevice.Resume();

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 		r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 		CHECK_EQUAL(stat[0].Int(),KErrNone);

 		timer.After(timerStat,timerInterval);

 		// second buffer

 		while (stat[1] == KRequestPending)

 			{

 			User::WaitForRequest(stat[1],timerStat);

 			Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			if (stat[1] == KRequestPending) // still playing

 				{

 				CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 		r = TxSoundDevice.TimePlayed(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(timeIntervalBuf().Int64()),I64LOW(timeIntervalBuf().Int64()));

 		CHECK_EQUAL(stat[1].Int(),KErrNone);

 		// clean up

 		timer.Close();

 		chunk.Close();

 		for (i=0;i<2;i++)

 			delete tPtr[i];

 		} // channel loop

 	}

 void TestTimeRecorded()

 	{

 	TTimeIntervalMicroSecondsBuf timeIntervalBuf;

 	TInt r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 	if (r == KErrNotSupported)

 		{

 		Test.Printf(_L("TimeRecorded() is not supported, skipping tests\n"));

 		return;

 		}

 	CHECK_NOERROR(r);

 	TInt rate;

 	// Find first supported rate and set the the audio configuration to use it

 	for (rate = 0; rate <= ESoundRate48000Hz; ++rate)

 		{

 		if (PlayCapsBuf().iRates & (1 << rate))

 			{

 			break;

 			}

 		}

 	// Test mono and Stereo

 	for (TInt channels=1; channels<=2; ++channels)

 	{

 		TRequestStatus stat[2];

 		Test.Next(_L("Preparing to record..."));

 		if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

 			RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

 		RecordFormatBuf().iRate = (TSoundRate) rate;

 		RecordFormatBuf().iChannels = channels;

 		PrintConfig(RecordFormatBuf(),Test);

 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 		CHECK_NOERROR(r);

 		// Set the play buffer configuration, then read it back.

 		RChunk chunk;

 		TInt bufSize=BytesPerSecond(RecordFormatBuf()); 									// Large enough to hold 1 second of data.

 		bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());		// Keep the buffer length valid for driver.

 		TTestSharedChunkBufConfig bufferConfig;

 		bufferConfig.iNumBuffers=4;

 		bufferConfig.iBufferSizeInBytes=bufSize;

 		bufferConfig.iFlags=0;		// All buffers will be contiguous

 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

 		r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

 		CHECK_NOERROR(r);

 		RxSoundDevice.GetBufferConfig(bufferConfigBuf);

 		PrintBufferConf(bufferConfig,Test);

 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

 		// set up a timer to interrogate time played

 		TRequestStatus timerStat;

 		RTimer timer;

 		timer.CreateLocal();

 		TTimeIntervalMicroSeconds32 timerInterval(50000);

 		TInt64 currentTime, previousTime;

 		Test.Next(_L("Time Recorded..."));

 		currentTime = previousTime = MAKE_TINT64(0,0);

 		TInt length1=0, length2=0;

 		RxSoundDevice.RecordData(stat[0],length1);

 		RxSoundDevice.RecordData(stat[1],length2);

 		// check requests are pending

 		CHECK_EQUAL(stat[0].Int(),KRequestPending);

 		CHECK_EQUAL(stat[1].Int(),KRequestPending);

 		// check time played is not supported for record channel

 		CHECK(RxSoundDevice.TimePlayed(timeIntervalBuf)==KErrNotSupported);

 		timer.After(timerStat,timerInterval);

 		// first buffer

 		while (stat[0] == KRequestPending)

 			{

 			User::WaitForRequest(stat[0],timerStat);

 			Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 		r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 		CHECK(stat[0].Int() == 0);

 		timer.After(timerStat,timerInterval);

 		// second buffer

 		while (stat[1] == KRequestPending)

 			{

 			User::WaitForRequest(stat[1],timerStat);

 			Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			if (stat[1] == KRequestPending) // still playing

 				{

 				CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[1] %x, timerStat %x\n"),stat[1].Int(),timerStat.Int());

 		r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(timeIntervalBuf().Int64()),I64LOW(timeIntervalBuf().Int64()));

 		CHECK(stat[1].Int() > 0);

 		// stop recording into the next buffer

 		RxSoundDevice.CancelRecordData();

 		// Release the buffers

 		r = RxSoundDevice.ReleaseBuffer(stat[0].Int());

 		CHECK_EQUAL(r, KErrNone);

 		r = RxSoundDevice.ReleaseBuffer(stat[1].Int());

 		CHECK_EQUAL(r, KErrNone);

 		//

 		// Time Recorded with pause

 		//

 		Test.Next(_L("Time Recorded with pause..."));

 		TTimeIntervalMicroSeconds32 pauseInterval(2000000);

 		TBool paused = EFalse;

 		currentTime = previousTime = MAKE_TINT64(0,0);

 	    // Record and discard some data to make sure all testing is not within the first buffer...

 		RxSoundDevice.RecordData(stat[0],length1);

         User::WaitForRequest(stat[0]);

         CHECK(stat[0].Int() >= 0);

         RxSoundDevice.ReleaseBuffer(stat[0].Int());

 		RxSoundDevice.RecordData(stat[0],length1);

         RxSoundDevice.RecordData(stat[1],length2);

 		// check requests are pending

 		CHECK_EQUAL(stat[0].Int(),KRequestPending);

 		// check time recorded is not supported for play channel

 		CHECK(RxSoundDevice.TimePlayed(timeIntervalBuf)==KErrNotSupported);

 		timer.After(timerStat,timerInterval);

 		// first buffer

 		while (stat[0] == KRequestPending)

 			{

 			User::WaitForRequest(stat[0],timerStat);

 			Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 			// Pause and resume ...

 			if (paused == EFalse && I64LOW(currentTime) > 500000)

 				{

 				paused = ETrue;

 				RxSoundDevice.Pause();

 				r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 				CHECK_NOERROR(r);

 				TInt64 pausedTime1 = timeIntervalBuf().Int64();

 				Test.Printf(_L("Paused time_high %d, time_low %d\n"),I64HIGH(pausedTime1),I64LOW(pausedTime1));

 	            // Check time is increasing

 	            CHECK((I64LOW(pausedTime1) >= I64LOW(currentTime)));

 				User::After(pauseInterval);

 				r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 				CHECK_NOERROR(r);

 				TInt64 pausedTime2 = timeIntervalBuf().Int64();

 				Test.Printf(_L("Resumed time_high %d, time_low %d\n"),I64HIGH(pausedTime2),I64LOW(pausedTime2));

                 // Check time is unchanged

                 CHECK((I64LOW(pausedTime2) == I64LOW(pausedTime1)));

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		// Buffer should complete normally or be empty (indicated by KErrCancel)

 		CHECK((stat[0].Int() >= 0) || (stat[0].Int() == KErrCancel));

 		// Release the first buffer, if it contained any data

 		if (stat[0].Int() >= 0)

 			{

 			r = RxSoundDevice.ReleaseBuffer(stat[0].Int());

 			CHECK_EQUAL(r, KErrNone);

 			}

 		// Check second buffer completed or cancelled

 		User::WaitForRequest(stat[1]);

 		CHECK_EQUAL(stat[1].Int(), KErrCancel);

 		// Now resume the recording

 		r = RxSoundDevice.Resume();

 		CHECK_EQUAL(r, KErrNone);

 		// Need to re-setup buffers

 		RxSoundDevice.RecordData(stat[0],length1);

 		RxSoundDevice.RecordData(stat[1],length2);

 		timer.After(timerStat,timerInterval);

 		// another buffer

 		while (stat[0] == KRequestPending)

 			{

 			User::WaitForRequest(stat[0],timerStat);

 			Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 			previousTime = currentTime;

 			r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 			CHECK_NOERROR(r);

 			currentTime = timeIntervalBuf().Int64();

 			Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(currentTime),I64LOW(currentTime));

 			// ensure time is increasing or function is not supported

 			if (stat[0] == KRequestPending) // still recording

 				{

 				CHECK((I64LOW(currentTime) >= I64LOW(previousTime)) || r == KErrNotSupported);

 				}

 			if (timerStat != KRequestPending)

 				{

 				timer.After(timerStat,timerInterval);

 				}

 			}

 		timer.Cancel();

 		Test.Printf(_L("stat[0] %x, timerStat %x\n"),stat[0].Int(),timerStat.Int());

 		r = RxSoundDevice.TimeRecorded(timeIntervalBuf);

 		CHECK_NOERROR(r);

 		currentTime = timeIntervalBuf().Int64();

 		Test.Printf(_L("time_high %d, time_low %d\n"),I64HIGH(timeIntervalBuf().Int64()),I64LOW(timeIntervalBuf().Int64()));

 		CHECK(stat[0].Int() > 0);

 		// stop recording into the next buffer

 		RxSoundDevice.CancelRecordData();

 		// Release the buffers

 		r = RxSoundDevice.ReleaseBuffer(stat[0].Int());

 		CHECK_EQUAL(r, KErrNone);

 		// clean up

 		timer.Close();

 		chunk.Close();

 		} // channel loop

 	}

 TInt E32Main()

 	{

 //	User::SetDebugMask(0x10,1); // Enable KSOUND1

 	__UHEAP_MARK;

 	TInt r;

 	Test.Title();

 	Test.Start(_L("Load"));

 	if (Load()==KErrNotFound)

 		{

 		Test.Printf(_L("Shared chunk sound driver not supported - test skipped\r\n"));

 		Test.End();

 		Test.Close();

 		__UHEAP_MARKEND;

 		return(KErrNone);

 		}

 	__KHEAP_MARK;

 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-223

 	@SYMTestCaseDesc 		Opening the channel - normal

 	@SYMTestPriority 		Critical

 	@SYMTestActions			1)	With the LDD and PDD installed and with all channels closed on the device,

 								open a channel for playback on the device.

 							2)	Without closing the playback channel, open a channel for record on the device.

 							3)	Close the playback channel and then open it again.

 							4)	Close the record channel and then open it again.

 	@SYMTestExpectedResults	1)	KErrNone - Channel opens successfully.

 							2)	KErrNone - Channel opens successfully.

 							3)	KErrNone - Channel re-opens successfully.

 							4)	KErrNone - Channel re-opens successfully.

 	@SYMREQ					PREQ1073.4 */

 	Test.Next(_L("Open playback channel"));

 	r = TxSoundDevice.Open(KSoundScTxUnit0);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Open record channel"));

 	r = RxSoundDevice.Open(KSoundScRxUnit0);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Query play formats supported"));

 	TxSoundDevice.Caps(PlayCapsBuf);

 	TSoundFormatsSupportedV02 playCaps=PlayCapsBuf();

 	PrintCaps(playCaps,Test);

 	Test.Next(_L("Close playback channel"));

 	TxSoundDevice.Close();

 	Test.Next(_L("Re-open playback channel"));

 	r = TxSoundDevice.Open(KSoundScTxUnit0);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Close record channel"));

 	RxSoundDevice.Close();

 	Test.Next(_L("Re-open record channel"));

 	r = RxSoundDevice.Open(KSoundScRxUnit0);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Query play formats supported"));

 	TxSoundDevice.Caps(PlayCapsBuf);

 	PrintCaps(playCaps,Test);

 	Test.Next(_L("Query record formats supported"));

 	RxSoundDevice.Caps(RecordCapsBuf);

 	TSoundFormatsSupportedV02 recordCaps=RecordCapsBuf();

 	PrintCaps(recordCaps,Test);

 	Test.Next(_L("Query current play settings"));

 	TxSoundDevice.AudioFormat(PlayFormatBuf);

 	TCurrentSoundFormatV02 playFormat=PlayFormatBuf();

 	PrintConfig(playFormat,Test);

 	CheckConfig(playFormat,playCaps);

 	Test.Next(_L("Query current record settings"));

 	RxSoundDevice.AudioFormat(RecordFormatBuf);

 	TCurrentSoundFormatV02 recordFormat=RecordFormatBuf();

 	PrintConfig(recordFormat,Test);

 	CheckConfig(recordFormat,recordCaps);

 	Test.Next(_L("Set play format"));

 	if (playCaps.iEncodings&KSoundEncoding16BitPCM)

 		playFormat.iEncoding = ESoundEncoding16BitPCM;

 	PrintConfig(playFormat,Test);

 	r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

 	CHECK_NOERROR(r);

 	Test.Next(_L("Set Record Format"));

 	if (recordCaps.iEncodings&KSoundEncoding16BitPCM)

 		recordFormat.iEncoding = ESoundEncoding16BitPCM;

 	PrintConfig(recordFormat,Test);

 	r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

 	CHECK_NOERROR(r);

 #ifdef SOAKTEST

 	TInt freeRamInBytes=0;

 	TTime stim;

 	stim.HomeTime();

 	FOREVER

 		{

 #endif

 		TestBasicPlayFunctions();

 		TestBasicRecordFunctions();

 		TestPlayAllRates(1,4);

 		TestPlayAllRates(2,4);

 		TestRecordAllRates(1,4);

 		TestRecordAllRates(2,4);

 		TestRecordVolume(2,10);

 		TestPlayCancel();

 		TestRecordCancel();

 		TestRecordPauseResume(1);

 		TestRecordPauseResume(2);

 		TestSimultaneousPlayRecord();

 		TestTimePlayed();

 		TestTimeRecorded();

 #ifdef __WINS__

 		TestDefectDTWMM00678();

 #endif

         //TestSpeed(); // Gives information which may help debug h4 FMM issues

 #ifdef SOAKTEST

 		TInt free;

 		HAL::Get(HAL::EMemoryRAMFree,free);

 	Test.Printf(_L("Free ram is %d bytes\r\n"),free);

 //	if (freeRamInBytes)

 //		CHECK(freeRamInBytes == free)

 	freeRamInBytes=free;

 	TTime ntim;

 		ntim.HomeTime();

 		TTimeIntervalMinutes elapsed;

 		r=ntim.MinutesFrom(stim,elapsed);

 		CHECK_NOERROR(r);

 		Test.Printf(_L("Test has been running for %d minutes\r\n"),elapsed.Int());

 		}

 #endif

 	Test.Next(_L("Close channels"));

 	RxSoundDevice.Close();

 	TxSoundDevice.Close();

 	__KHEAP_MARKEND;

 	// Now that both the channels are closed, unload the LDD and the PDDs.

 	TestUnloadDrivers();

 	Test.End();

 	Test.Close();

 	Cleanup();

 	__UHEAP_MARKEND;

 	User::Allocator().Check();

 	return(KErrNone);

 	}