// Copyright (c) 2000-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:

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <e32test.h>

#include "randgen.h"

#include "user_config.h"

RTest test( _L("TF_READ") );

const TInt KTestUserDataSize = 1024;

const TInt KBufferGuardSize = 16384;

const TInt KMaxWriteLength = 512;

const TInt64 KSampleDataRandomSeed = MAKE_TINT64(0x3e000111,0xAFCBDF0F);

const TInt64 KRandomTestSeed = MAKE_TINT64(0x90009901,0xABEF1011);

enum TPanicNo

	{

	EPanicGetDesOverflow,

	EPanicGetDesInitialOverflow,

	EPanicCheckOverflow

	};

LOCAL_D void Panic( TPanicNo aPanic )

	{

	_LIT( KPanicCat, "TF_READ" );

	User::Panic( KPanicCat, aPanic );

	}

class CCheckedBuffer : public CBase

	{

	public:

		CCheckedBuffer( TInt auserDataSize, TInt aGuardSize );

		~CCheckedBuffer();

		void CreateL();

		void InitialiseGuard();

		TBool CheckGuard( TInt aUserDataLength ) const;

		TBool CheckGuardAtStartOfUserData( TInt aGuardLength ) const;

		void GetDes( TPtrC8& aDes ) const;

		void GetDes( TPtr8& aDes, TInt aInitialLength, TInt aMaxLength ) const;

	private:

		CCheckedBuffer();

	private:

		TPtr8	iUserData;		// pointer to user data area

		const TInt	iUserDataSize;

		const TInt	iGuardSize;

		TUint8*	iAllocCell;

	};

CCheckedBuffer::CCheckedBuffer( TInt aUserDataSize, TInt aGuardSize )

	: iUserData(0,0), iUserDataSize( aUserDataSize ), iGuardSize( aGuardSize )

	{

	}

CCheckedBuffer::~CCheckedBuffer()

	{

	delete iAllocCell;

	}

void CCheckedBuffer::CreateL()

	{

	TInt totalCellSizeRequired = iUserDataSize + (2 * iGuardSize);

	iAllocCell = (TUint8*)User::AllocL( totalCellSizeRequired );

	test.Printf( _L("Allocated heap cell for checked buffer\n") );

	iUserData.Set( iAllocCell + iGuardSize, iUserDataSize, iUserDataSize );

	}

void CCheckedBuffer::GetDes( TPtrC8& aDes ) const

	//

	// Create descriptor to the whole user data area in aDes

	//

	{

	aDes.Set( iAllocCell + iGuardSize, iUserDataSize );

	}

void CCheckedBuffer::GetDes( TPtr8& aDes, TInt aInitialLength, TInt aMaxLength ) const

	//

	// Create modifiable descriptor to the user data area in aDes,

	// with a maximum length aMaxLength, and initial length aInitialLength

	//

	{

	__ASSERT_ALWAYS( aMaxLength <= iUserDataSize, Panic(EPanicGetDesOverflow) );

	__ASSERT_ALWAYS( aInitialLength <= iUserDataSize, Panic(EPanicGetDesInitialOverflow) );

	aDes.Set( iAllocCell + iGuardSize, aInitialLength, aMaxLength );

	}

void CCheckedBuffer::InitialiseGuard()

	//

	// Create the guard regions

	//

	{

	TInt totalCellSize = User::AllocLen( iAllocCell );

	Mem::Fill( iAllocCell, totalCellSize, 0x5A );

	}

TBool CCheckedBuffer::CheckGuard( TInt aUserDataLength ) const

	//

	// Checks that the guard value is still present before the user data

	// area, and after aUserDataLength bytes of user data

	//

	{

	const TUint8* p = iAllocCell;

	const TUint8* pUserDataStart = iUserData.Ptr();

	for( ; p < pUserDataStart; p++ )

		{

		if( 0x5a != *p )

			{

			return EFalse;

			}

		}

	p = pUserDataStart + aUserDataLength;

	const TUint8* pEnd = iAllocCell + User::AllocLen( iAllocCell );

	for( ; p < pEnd; p++ )

		{

		if( 0x5a != *p )

			{

			return EFalse;

			}

		}

	return ETrue;

	}

TBool CCheckedBuffer::CheckGuardAtStartOfUserData( TInt aGuardLength ) const

	//

	// Checks that the first aGuardLength bytes of the user data area

	// contain the guard value

	//

	{

	const TUint8* p = iUserData.Ptr();

	const TUint8* pEnd = p + aGuardLength;

	for( ; p < pEnd; p++ )

		{

		if( 0x5a != *p )

			{

			return EFalse;

			}

		}

	return ETrue;

	}

class CReadTest : public CBase

	{

	public:

		~CReadTest();

		void CreateL();

		void DoTest();

	private:

		static TInt DummyThread( TAny* aParam );

		void CreateSampleData();

		static TBool CheckZero( const TPtrC8& aDes );

		void CreateTestData( TInt aBlockNumber, TBool aEndOfBlock );

		TBool CompareAgainstFlash( TInt aFlashOffset, const TPtrC8& aDes, TInt aDescOffset );

		void TestSimpleReads();

		void TestSimpleThreadReads();

		void TestUnalignedReads();

		void TestUnalignedThreadReads();

		void TestOffsetBufferThreadReads();

		void TestOffsetBufferUnalignedThreadReads();

		void TestReadsFromAllBlocks();

		void TestSimpleScatterReads1();

		void TestSimpleScatterReads2();

		void TestScatterGather();

		void TestReadAcrossBlock();

		void PerformCheckedRead( TInt aReadPos, TInt aReadLen );

		void PerformCheckedThreadRead( TInt aReadPos, TInt aReadLen, TInt aDescOffset );

	private:

		TInt			iFlashSize;

		TInt			iBlockSize;

		TInt			iBlockCount;

		TBusLocalDrive	iDrive;

		TBool			iDriveOpened;

		TBuf8<512>		iReadBuffer;

		TRandomGenerator	iRandom;

		TBuf8<KTestUserDataSize> iSampleData;

		CCheckedBuffer*	iBuffer;

		RThread			iDummyThread;

	};

CReadTest::~CReadTest()

	{

	if( iDriveOpened )

		{

		iDrive.Disconnect();

		}

	}

void CReadTest::CreateL()

	{

	//

	// Load the device drivers

	//

	TInt r;

#ifndef SKIP_PDD_LOAD

	test.Printf( _L("Loading %S\n"), &KLfsDriverName );

	r = User::LoadPhysicalDevice( KLfsDriverName );

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

#endif

#ifdef UNMOUNT_DRIVE

	RFs fs;

	test( KErrNone == fs.Connect() );

#if 0 // XXX - API violation on EKA2

	test( KErrNone == fs.SetDefaultPath( _L("Z:\\") ) );

#endif

	TFullName name;

	fs.FileSystemName( name, KLffsLogicalDriveNumber );

	if( name.Length() > 0 )

		{

		test.Printf( _L("Unmounting drive") );

		test( KErrNone == fs.DismountFileSystem( _L("Lffs"), KLffsLogicalDriveNumber) );

		User::After( 2000000 );

		test.Printf( _L("Drive unmounted") );

		}

	fs.Close();

#endif

	//

	// Open a TBusLogicalDevice to it

	//

	test.Printf( _L("Opening media channel\n") );

	TBool changedFlag = EFalse;

	r = iDrive.Connect( KDriveNumber, changedFlag );

	User::LeaveIfError( r );

	iDriveOpened = ETrue;

	//

	// Get size of Flash drive

	//

	TLocalDriveCapsV2Buf info;

    iDrive.Caps(info);

	iFlashSize = I64LOW(info().iSize);

	iBlockSize = info().iEraseBlockSize;

	iBlockCount = iFlashSize / iBlockSize;

	test.Printf( _L("Flash size is 0x%x bytes\n"), iFlashSize );

	//

	// Create a dummy thread that we can use to force

	// other-thread write operations

	//

#if 0

	test( KErrNone == iDummyThread.Create( _L("DUMMY"), DummyThread, 256, KMinHeapSize, KMinHeapSize, NULL ) );

#else

	// XXX TONYL

	test( KErrNone == iDummyThread.Create( _L("DUMMY"), DummyThread, KDefaultStackSize, KMinHeapSize, KMinHeapSize, NULL ) );

//	test.Printf( _L("== do it"));

//	TInt pas = iDummyThread.Create( _L("DUMMY"), DummyThread, KDefaultStackSize, KMinHeapSize, KMinHeapSize, NULL );

//	test.Printf( _L("CREATE = %d"), pas);

//	test (pas == KErrNone);

#endif

#if 1

	iDummyThread.Resume();

#endif

	//

	// Create a checked buffer

	//

	iBuffer = new(ELeave) CCheckedBuffer( KTestUserDataSize, KBufferGuardSize );

	iBuffer->CreateL();

	//

	// Seed the pseudo-random number generator

	//

	iRandom.SetSeed( KSampleDataRandomSeed );

	test.Printf( _L("CreateL complete\n") );

	}

TInt CReadTest::DummyThread( TAny* /* aParam */ )

	//

	// Thread does nothing at all

	//

	{

#if 1

	test.Printf( _L("== do it"));

#endif

	for(;;)

		{

		User::WaitForAnyRequest();	// just block

		}

	}

void CReadTest::TestSimpleReads()

	//

	// Makes reads of 1 byte to 512 bytes into the start of the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the simple read function from TBusLocalDrive, and 

	// reads from an aligned Flash address

	//

	{

	test.Next( _L("Testing simple reads\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		test.Printf( _L("Reading %d bytes\n"), readLen );

		//

		// Prepare the guard data

		//

		iBuffer->InitialiseGuard();

		//

		// Set up the descriptor, length=0, maxlen=readLen

		//

		iBuffer->GetDes( des, 0, readLen );

		//

		// Now read some data into it

		//

		test( KErrNone == iDrive.Read( 0, readLen, des ) );

		//

		// Check what we got

		//

		test( des.Length() == readLen );

		TPtrC8 newDes;

	iBuffer->GetDes( newDes );

		test( newDes.Ptr() == des.Ptr() );

		test( iBuffer->CheckGuard( readLen ) );

		test( CompareAgainstFlash( 0, des, 0 ) );

		}

	}

void CReadTest::TestSimpleThreadReads()

	//

	// Makes reads of 1 byte to 512 bytes into the start of the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the more complex read function from TBusLocalDrive, and 

	// reads from an aligned Flash address

	//

	{

	test.Next( _L("Testing simple reads using other-thread read function\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		test.Printf( _L("Reading %d bytes\n"), readLen );

		//

		// Prepare the guard data

		//

		iBuffer->InitialiseGuard();

		test.Printf( _L("AA\n"));

		//

		// Set up the descriptor, length=0, maxlen=readLen

		//

		iBuffer->GetDes( des, 0, readLen );

		test.Printf( _L("BB\n"));

		//

		// Now read some data into it

		//

		test( KErrNone == iDrive.Read( 0, readLen, &des, KLocalMessageHandle, 0 ) );

		test.Printf( _L("CC\n"));

#if 0

		test( KErrNone == iDrive.Read( 0, readLen, &des, iDummyThread.Handle(), 0 ) );

#else

		// XXX - this works

		test( KErrNone == iDrive.Read( 0, readLen, &des, KLocalMessageHandle, 0 ) );

#endif

		//

		// Check what we got

		//

		test.Printf( _L("DD\n"));

		test.Printf( _L("DD\n"));

		test.Printf( _L("DD\n"));

		test.Printf( _L("DD\n"));

		test( des.Length() == readLen );

		TPtrC8 newDes;

		test.Printf( _L("EE\n"));

		iBuffer->GetDes( newDes );

		test.Printf( _L("FF\n"));

		test( newDes.Ptr() == des.Ptr() );

		test( iBuffer->CheckGuard( readLen ) );

		test.Printf( _L("GG\n"));

		test( CompareAgainstFlash( 0, des, 0 ) );

		test.Printf( _L("HH\n"));

		}

	}

void CReadTest::TestUnalignedReads()

	//

	// Makes reads of 1 byte to 512 bytes into the start of the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the simple read function from TBusLocalDrive.

	// The data is read from an unaligned address (0ffset 1, 2, 3)

	//

	{

	test.Next( _L("Testing unaligned reads\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		//

		// Set up the descriptor, length=0, maxlen=readLen

		//

		iBuffer->GetDes( des, 0, readLen );

		//

		// Repeat for each offset

		//

		for( TInt offs = 1; offs < 4; offs++ )

			{

			test.Printf( _L("Reading %d unaligned bytes from offset %d\n"), readLen, offs );

			iBuffer->InitialiseGuard();

			test( KErrNone == iDrive.Read( offs, readLen, des ) );

			test( des.Length() == readLen );

			TPtrC8 newDes;

			iBuffer->GetDes( newDes );

			test( newDes.Ptr() == des.Ptr() );

			test( iBuffer->CheckGuard( readLen ) );

			test( CompareAgainstFlash( offs, des, 0 ) );

			}

		}

	}

void CReadTest::TestUnalignedThreadReads()

	//

	// Makes reads of 1 byte to 512 bytes into the start of the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the thread read function from TBusLocalDrive.

	// The data is read from an unaligned address (0ffset 1, 2, 3)

	//

	{

	test.Next( _L("Testing unaligned other-thread reads\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		//

		// Set up the descriptor, length=0, maxlen=readLen

		//

		iBuffer->GetDes( des, 0, readLen );

		//

		// Repeat for each offset

		//

		for( TInt offs = 1; offs < 4; offs++ )

			{

			test.Printf( _L("Reading %d unaligned bytes from offset %d\n"), readLen, offs );

			iBuffer->InitialiseGuard();

#if 0

			test( KErrNone == iDrive.Read( offs, readLen, &des, iDummyThread.Handle(), 0 ) );

#else

			test( KErrNone == iDrive.Read( offs, readLen, &des, KLocalMessageHandle, 0 ) );

#endif

			test( des.Length() == readLen );

			TPtrC8 newDes;

			iBuffer->GetDes( newDes );

			test( newDes.Ptr() == des.Ptr() );

			test( iBuffer->CheckGuard( readLen ) );

			test( CompareAgainstFlash( offs, des, 0 ) );

			}

		}

	}

void CReadTest::TestOffsetBufferThreadReads()

	//

	// Makes reads of 1 byte to 512 bytes to an offset position in the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the more complex read function from TBusLocalDrive, and 

	// reads from an aligned Flash address

	//

	{

	test.Next( _L("Testing other-thread reads into offset position in descriptor\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		test.Printf( _L("Reading %d bytes\n"), readLen );

		//

		// Repeat test for offsets 0..64 in buffer

		//

		for( TInt destOffset = 1; destOffset < 64; destOffset++ )

			{

//			test.Printf( _L("... dest offset = %d"), destOffset );

			//

			// Prepare the guard data

			//

			iBuffer->InitialiseGuard();

			//

			// Set up the descriptor, length=0, maxlen=readLen+destOffset

			//

			iBuffer->GetDes( des, 0, readLen + destOffset );

#if 0

			test( KErrNone == iDrive.Read( 0, readLen, &des, iDummyThread.Handle(), destOffset ) );

#else

			test( KErrNone == iDrive.Read( 0, readLen, &des, KLocalMessageHandle, destOffset ) );

#endif

			//

			// Check what we got

			//

			test( des.Length() == readLen + destOffset );

			TPtrC8 newDes;

			iBuffer->GetDes( newDes );

			test( newDes.Ptr() == des.Ptr() );

			//

			// end of written data is at readLen + destOffset

			//

			test( iBuffer->CheckGuard( readLen+destOffset ) );

			//

			// check the section between that start of the user data and

			// the offset position still contains guard data

			//

			test( iBuffer->CheckGuardAtStartOfUserData( destOffset ) );

			test( CompareAgainstFlash( 0, des, destOffset ) );

			}

		}

	}

void CReadTest::TestOffsetBufferUnalignedThreadReads()

	//

	// Makes reads of 1 byte to 512 bytes to an offset position in the

	// checked buffer and tests that only the expected bytes have changed

	// This uses the more complex read function from TBusLocalDrive, and 

	// reads from an aligned Flash address

	//

	{

	test.Next( _L("Testing other-thread unaligned reads into offset position in descriptor\n") );

	//

	// Descriptor to user data area, passed to media driver

	//

	TPtr8 des(0,0);

	for( TInt readLen = 1; readLen <= 500; readLen++ )

		{

		test.Printf( _L("Reading %d bytes\n"), readLen );

		//

		// Repeat test for offsets 0..64 in buffer

		//

		for( TInt destOffset = 1; destOffset < 64; destOffset++ )

			{

//			test.Printf( _L("... dest offset = %d"), destOffset );

			//

			// repeat for each source offset

			//

			for( TInt offs = 1; offs < 4; offs++ )

				{

				//

				// Prepare the guard data

				//

				iBuffer->InitialiseGuard();

				//

				// Set up the descriptor, length=0, maxlen=readLen+destOffset

				//

				iBuffer->GetDes( des, 0, readLen + destOffset );

#if 0

				test( KErrNone == iDrive.Read( offs, readLen, &des, iDummyThread.Handle(), destOffset ) );

#else

				test( KErrNone == iDrive.Read( offs, readLen, &des, KLocalMessageHandle, destOffset ) );

#endif

				//

				// Check what we got

				//

				test( des.Length() == readLen + destOffset );

				TPtrC8 newDes;

				iBuffer->GetDes( newDes );

				test( newDes.Ptr() == des.Ptr() );

				//

				// end of written data is at readLen + destOffset

				//

				test( iBuffer->CheckGuard( readLen+destOffset ) );

				//

				// check the section between that start of the user data and

				// the offset position still contains guard data

				//

				test( iBuffer->CheckGuardAtStartOfUserData( destOffset ) );

				test( CompareAgainstFlash( offs, des, destOffset ) );

				} // end for

			}

		}

	}

void CReadTest::PerformCheckedRead( TInt aReadPos, TInt aReadLen )

	{

	TPtr8 des(0,0);

	iBuffer->InitialiseGuard();

	iBuffer->GetDes( des, 0, aReadLen );

	test.Printf( _L("Reading %d byte(s) from offset 0x%x\n"), aReadLen, aReadPos );

	test( KErrNone == iDrive.Read( aReadPos, aReadLen, des ) );

	test( des.Length() == aReadLen );

	test( iBuffer->CheckGuard( aReadLen ) );

	test( CompareAgainstFlash( aReadPos, des, 0 ) );

	}

void CReadTest::PerformCheckedThreadRead( TInt aReadPos, TInt aReadLen, TInt aDescOffset )

	{

	TPtr8 des(0,0);

	iBuffer->InitialiseGuard();

	iBuffer->GetDes( des, 0, aReadLen + aDescOffset );

	test.Printf( _L("Reading %d byte(s) from offset 0x%x to thread descriptor offset %d\n"), aReadLen, aReadPos, aDescOffset );

#if 0

	test( KErrNone == iDrive.Read( aReadPos, aReadLen, &des, iDummyThread.Handle(), aDescOffset ) );

#else

	test( KErrNone == iDrive.Read( aReadPos, aReadLen, &des, KLocalMessageHandle, aDescOffset ) );

#endif

//	test.Printf( _L("Check descriptor length") );

	test( des.Length() == aReadLen + aDescOffset );

//	test.Printf( _L("Check guard") );

	test( iBuffer->CheckGuard( aReadLen + aDescOffset ) );

//	test.Printf( _L("Check guard at start of descriptor") );

	test( iBuffer->CheckGuardAtStartOfUserData( aDescOffset ) );

	test( CompareAgainstFlash( aReadPos, des, aDescOffset ) );

	}

void CReadTest::TestReadsFromAllBlocks()

	//

	// Does some spot-test reads from all blocks to make sure

	// that reading across the whole Flash works

	//

	{

	test.Next( _L("Testing reads from all blocks\n") );

	for( TInt block = 0; block < iBlockCount; block++ )

		{

		test.Printf( _L("Reading from block %d"), block );

		TInt readBase = (block * iBlockSize);

		PerformCheckedRead( readBase, 1 );

		PerformCheckedRead( readBase, 24 );

		PerformCheckedRead( readBase, 99 );

		PerformCheckedRead( readBase, 511 );

		PerformCheckedRead( readBase+1, 1 );

		PerformCheckedRead( readBase+1, 24 );

		PerformCheckedRead( readBase+1, 99 );

		PerformCheckedRead( readBase+1, 511 );

		PerformCheckedRead( readBase+3, 1 );

		PerformCheckedRead( readBase+3, 24 );

		PerformCheckedRead( readBase+3, 99 );

		PerformCheckedRead( readBase+3, 511 );

		PerformCheckedThreadRead( readBase, 1, 0 );

		PerformCheckedThreadRead( readBase, 24, 0 );

		PerformCheckedThreadRead( readBase, 99, 2 );

		PerformCheckedThreadRead( readBase, 511, 0 );

		PerformCheckedThreadRead( readBase+1, 1, 11 );

		PerformCheckedThreadRead( readBase+1, 24, 4 );

		PerformCheckedThreadRead( readBase+1, 99, 24 );

		PerformCheckedThreadRead( readBase+1, 511, 0 );

		PerformCheckedThreadRead( readBase+3, 1, 32 );

		PerformCheckedThreadRead( readBase+3, 24, 333 );

		PerformCheckedThreadRead( readBase+3, 99, 0 );

		PerformCheckedThreadRead( readBase+3, 511, 1 );

		}

	}

void CReadTest::TestSimpleScatterReads1()

	//

	// Does some simple reads of varying length from the

	// blocks in pseudo-random order.

	//

	{

	test.Next( _L("Testing simple scatter reads\n") );

	TRandomGenerator random;

	random.SetSeed( KRandomTestSeed );

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		TInt block = random.Next() % iBlockCount;

		test.Printf( _L("Reading block %d"), block );

		TInt readBase = (block * iBlockSize);

		PerformCheckedRead( readBase, readLen );

		}

	}

void CReadTest::TestSimpleScatterReads2()

	//

	// Does some simple reads of varying length from the

	// blocks in pseudo-random order.

	//

	// This is similar to TestSimpleScatterReads1 except that

	// as the length reduces the read position is moved along

	// and the test uses the thread-read variant

	//

	{

	test.Next( _L("Testing simple scatter reads\n") );

	TRandomGenerator random;

	random.SetSeed( KRandomTestSeed );

	for( TInt readLen = 1; readLen <= 512; readLen++ )

		{

		TInt block = random.Next() % iBlockCount;

		test.Printf( _L("Reading block %d"), block );

		TInt readBase = (block * iBlockSize) + (512 - readLen);

		PerformCheckedRead( readBase, readLen );

		}

	}

void CReadTest::TestScatterGather()

	//

	// This reads bytes from all over the Flash and concatenates

	// them into a single descriptor. This isn't representative of

	// anything a real filesystem would do (at present!) but

	// is an interesting test of the media driver

	//

	{

	test.Next( _L("Testing scatter-gather reads\n") );

	TRandomGenerator random;

	random.SetSeed( KRandomTestSeed );

	const TInt KMaxReads = 500;

	struct SReadInfo

		{

		TInt	iOffset;

		TInt	iLength;

		};

	SReadInfo* readInfoArray = new SReadInfo[KMaxReads];

	test( NULL != readInfoArray );

	TPtr8 des(0,0);

	iBuffer->InitialiseGuard();

	iBuffer->GetDes( des, 0, KTestUserDataSize );

	TInt descOffset = 0;

	TInt readCount;

	for( readCount = 0; readCount < KMaxReads; readCount++ )

		{

		//

		// Create random read position and length

		//

		TInt block = random.Next() % iBlockCount;

		TInt blockOffset = random.Next() % 1000;

		if( blockOffset > 500 )

			{

			blockOffset = iBlockSize - 1 - blockOffset;

			}

		TInt readOffset = (block * iBlockSize) + blockOffset;

		TInt readLength = (random.Next() % 8) + 1;

		if( des.Length() + readLength > des.MaxLength() )

			{

			break;	// finished

			}

		//

		// Save the position & length

		//

		readInfoArray[readCount].iOffset = readOffset;

		readInfoArray[readCount].iLength = readLength;

		//

		// do the read

		//

		_LIT( KScatterReadMsg, "Reading Flash @%x %d bytes to desc offset %d" );

		test.Printf( KScatterReadMsg, readOffset, readLength, descOffset );

#if 0

		test( KErrNone == iDrive.Read( readOffset, readLength, &des, iDummyThread.Handle(), descOffset ) );

#else

		test( KErrNone == iDrive.Read( readOffset, readLength, &des, KLocalMessageHandle, descOffset ) );

#endif

		test( des.Length() == descOffset + readLength );

		descOffset += readLength;

		}

	//

	// Now check all the data against the Flash contents

	//

	descOffset = 0;

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

		{

		TInt readOffset = readInfoArray[i].iOffset ;

		TInt readLength = readInfoArray[i].iLength;

		TPtrC8 ptr( des.Ptr() + descOffset, readLength );

		test( CompareAgainstFlash( readOffset, ptr, 0 ) );

		descOffset += readLength;

		}

	delete[] readInfoArray;

	}

void CReadTest::TestReadAcrossBlock()

	//

	// Test reads that cross a block boundary

	//

	{

	test.Next( _L("Testing reads across block boundary\n") );

	for( TInt block = 1; block < iBlockCount - 1; block++ )

		{

		for( TInt readLen = 2; readLen <= 1024; readLen++ )

			{

			TInt blockBase = (block * iBlockSize);

			TInt readOffs = blockBase + (iBlockSize - (readLen/2));

			PerformCheckedRead( readOffs, readLen );

			}

		}

	}

void CReadTest::CreateSampleData()

	//

	// Fills iSampleData with pseudo-random test data

	//

	{

	TUint32* p = (TUint32*)iSampleData.Ptr();

	for( TInt j = 0; j < KTestUserDataSize/4; j++ )

		{

		*p++ = iRandom.Next();

		}

	iSampleData.SetLength( KTestUserDataSize );

	}

TBool CReadTest::CheckZero( const TPtrC8& aDes )

	//

	// Checks that all bytes in aDes are zero

	//

	{

	for( TInt i = aDes.Length(); i > 0; )

		{

		--i;

		if( 0 != aDes[i] )

			{

			return EFalse;

			}

		}

	return ETrue;

	}

void CReadTest::CreateTestData( TInt aBlockNumber, TBool aEndOfBlock )

	//

	// Writes some test data to the Flash. If aEndOfBlock is EFalse the

	// data is created at the start of the block. If it is ETrue then

	// the data is created right at the end of the block

	//

	{

	test.Printf( _L("Writing test data to Flash block %d\n"), aBlockNumber );

	//

	// Generate some test data

	//

	CreateSampleData();

	test.Printf( _L("Erasing block") );

	TInt writeBaseOffset = (aBlockNumber * iBlockSize);

	test( KErrNone == iDrive.Format( writeBaseOffset, iBlockSize ) );

	TInt writeCount = iSampleData.Length() / KMaxWriteLength;

	TInt r = KErrNone;

	if( aEndOfBlock )

		{

		writeBaseOffset += iBlockSize - iSampleData.Length();

		}

	TInt writeOffset = writeBaseOffset;

	const TUint8* src = iSampleData.Ptr();