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