// 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 );