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

 //

 #ifndef __TF_WRITE_H__

 #define __TF_WRITE_H__

 #include <e32std.h>

 enum TPanicNo

 	{

 	EPanicGetDesOverflow,

 	EPanicGetDesInitialOverflow,

 	EPanicCheckOverflow,

 	EPanicCompareDescOverflow,

 	EPanicEraseBlockOOR,

 	EPanicEraseBlockNeg,

 	EPanicJoinMaths

 	};

 GLREF_C void Panic( TPanicNo aPanic );

 class CWriteTest;

 class MGeneralizedWrite

 	//

 	// Provides an generic interface to a write function which

 	// can be either the simple of thread version. Used to hide which

 	// version of the write function a test is using

 	//

 	{

 	public:

 		virtual void Write(TInt aPos,const TDesC8& aSrc) = 0;

 		virtual void CheckedWrite(TInt aPos,const TDesC8& aSrc) = 0;

 	};

 class TWriteBase: public MGeneralizedWrite

 	{

 	public:

 		TWriteBase( CWriteTest& aOwner );

 		virtual void CheckedWrite(TInt aPos,const TDesC8& aSrc);

 	protected:

 		CWriteTest&	iOwner;

 	};

 class TSimpleWrite : public TWriteBase

 	//

 	// Simple implementation of write function

 	//

 	{

 	public:

 		TSimpleWrite( CWriteTest& aOwner );

 		virtual void Write( TInt aPos, const TDesC8& aSrc );

 	private:

 		TBusLocalDrive&	iDrive;

 	};

 class TThreadWrite : public TWriteBase

 	//

 	// Thread implementation of write function

 	//

 	{

 	public:

 		TThreadWrite( CWriteTest& aOwner );

 		virtual void Write(TInt aPos,const TDesC8& aSrc);

 		// Thread functions with offset, added by this class

 		void CheckedThreadWrite(TInt aPos, TInt aLength, const TDesC8& aSrc, TInt aDescOffset );

 		void CurrentThreadCheckedThreadWrite(TInt aPos, TInt aLength, const TDesC8& aSrc, TInt aDescOffset );

 	private:

 		TBusLocalDrive& iDrive;

 		const TInt iThreadHandle;

 	};

 class CBlockManager : public CBase

 	//

 	// class used to control erasing and allocation of blocks

 	//

 	{

 	public:

 		CBlockManager( TBusLocalDrive& iDrive, CWriteTest& aOwner );

 		~CBlockManager();

 		void CreateL();

 		void EraseBlock( TInt aBlockNumber );

 		void EraseAllBlocks();

 		void VerifyErased( TInt aBlockNumber );

 		void InitialiseSequentialBlockAllocator();

 		TInt NextErasedBlock();

 		void InitialiseDataChunkAllocator();

 		TUint NextErasedDataChunk( TInt aRequiredLength, TInt aMultiple=4 );

 		inline TInt BlockCount() const;

 		inline TInt BlockSize() const;

 		inline TInt FlashSize() const;

 		inline TUint BlockAddress( TInt aBlockNumber ) const;

 	private:

 		TBusLocalDrive&	iDrive;

 		TBuf8<512>	iReadBuffer;

 		CWriteTest&	iOwner;

 		TInt	iBlockCount;

 		TInt	iBlockSize;

 		enum TEraseStatus

 			{

 			EErased,

 			ENotErased

 			};

 		TEraseStatus*	iEraseArray;

 		TInt iNextBlock;

 		TInt iDataBlock;

 		TInt iDataOffset;

 	};

 class CWriteTest : public CBase

 	{

 	public:

 		~CWriteTest();

 		void CreateL();

 		void DoTests();

 		TBool CompareAgainstFlash( TInt aFlashOffset, const TDesC8& aDes );

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

 		inline const TUint8* ChunkBase() const;

 		inline TBusLocalDrive& Drive();

 		inline TInt DummyThreadHandle() const;

 	private:

 		static TInt DummyThread( TAny* aParam );

 		void CreateRandomData( TDes8& aDestBuf, TInt aLength );

 		TBool CheckOnes( TUint aFlashOffset, TInt aLength );

 		void CreateTestData( TInt aBlockNumber, TBool aEndOfBlock );

 		void SimpleWriteTest();

 		void SimpleThreadWriteTest();

 		void DoSimpleWriteTest( MGeneralizedWrite& aWriter );

 		void AlignedWriteTest();

 		void AlignedThreadWriteTest();

 		void DoAlignedWriteTest( MGeneralizedWrite& aWriter );

 		void UnalignedWriteTest();

 		void UnalignedThreadWriteTest();

 		void DoUnalignedWriteTest( MGeneralizedWrite& aWriter );

 		void OffsetDescriptorAlignedWriteTest();

 		void OffsetDescriptorUnalignedWriteTest();

 		void OffsetDescriptorCurrentThreadAlignedWriteTest();

 		void OffsetDescriptorCurrentThreadUnalignedWriteTest();

 		void JoinedWriteTest();

 		void JoinedThreadWriteTest();

 		void SingleBitOverwriteTest();

 		void TwoBitOverwriteTest();

 		void RunSimulationTest();

 	private:

 		TBusLocalDrive	iDrive;

 		TBool			iDriveOpened;

 		TBuf8<512>		iReadBuffer;

 		CBlockManager*	iBlocks;

 		TRandomGenerator	iRandom;

 		TSimpleWrite*	iSimpleWriter;

 		TThreadWrite*	iThreadWriter;

 		RThread	iDummyThread;

 	};

 inline TBusLocalDrive& CWriteTest::Drive()

 	{

 	return iDrive;

 	}

 inline TInt CWriteTest::DummyThreadHandle() const

 	{

 	return iDummyThread.Handle();

 	}

 #endif