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

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <e32test.h>

#include "randgen.h"

#include "user_config.h"

#include "tf_write.h"

_LIT( KTestName, "TF_WRITE" );

RTest test( KTestName );

const TInt64 KRandomSeed1(MAKE_TINT64(0x3e000111,0xAFCBDF0F));

GLDEF_C void Panic( TPanicNo aPanic )

	{

	User::Panic( KTestName, aPanic );

	}

// **********************************************************************

// Implementation of the writer classes

TWriteBase::TWriteBase( CWriteTest& aOwner )

	: iOwner( aOwner )

	{

	}

void TWriteBase::CheckedWrite(TInt aPos,const TDesC8& aSrc)

	{

	Write( aPos, aSrc );

	test( iOwner.CompareAgainstFlash( aPos, aSrc ) );

	}

TSimpleWrite::TSimpleWrite( CWriteTest& aOwner )

	: TWriteBase( aOwner ), iDrive( aOwner.Drive() )

	{

	}

void TSimpleWrite::Write(TInt aPos,const TDesC8& aSrc)

	{

	TInt64	pos( aPos );

//	test( KErrNone == iDrive.Write( pos, aSrc ) );

	TInt rv = iDrive.Write( pos, aSrc );

	if( KErrNone != rv )

		{

		test.Printf( _L("TBusLocalDrive::Write returned %d"), rv );

		test( EFalse );

		}

	}

TThreadWrite::TThreadWrite( CWriteTest& aOwner )

	: TWriteBase( aOwner ), iDrive( aOwner.Drive() ),

	iThreadHandle( aOwner.DummyThreadHandle() )

	{

	}

void TThreadWrite::Write(TInt aPos,const TDesC8& aSrc)

	{

	TInt64	pos( aPos );

#if 0

	test( KErrNone == iDrive.Write( pos, aSrc.Length(), &aSrc, iThreadHandle, 0 ) );

#else

	test( KErrNone == iDrive.Write( pos, aSrc.Length(), &aSrc, KLocalMessageHandle, 0 ) );

#endif

	}

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

	{

	TInt64	pos( aPos );

#if 0

	test( KErrNone == iDrive.Write( pos, aLength, &aSrc, iThreadHandle, aDescOffset ) );

#else

	test( KErrNone == iDrive.Write( pos, aLength, &aSrc, KLocalMessageHandle, aDescOffset ) );

#endif

	test( iOwner.CompareAgainstFlash( aPos, aLength, aSrc, aDescOffset ) );

	}

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

	{

	TInt64	pos( aPos );

#if 0

	test( KErrNone == iDrive.Write( pos, aLength, &aSrc, RThread().Handle(), aDescOffset ) );

#else

	test( KErrNone == iDrive.Write( pos, aLength, &aSrc, KLocalMessageHandle, aDescOffset ) );

#endif

	test( iOwner.CompareAgainstFlash( aPos, aLength, aSrc, aDescOffset ) );

	}

// **********************************************************************

// Implementation of CBlockManager

CBlockManager::CBlockManager( TBusLocalDrive& aDrive, CWriteTest& aOwner )

	: iDrive( aDrive ), iOwner( aOwner )

	{

	}

CBlockManager::~CBlockManager()

	{

	delete[] iEraseArray;

	}

void CBlockManager::CreateL()

	{

	//

	// Get size of Flash drive

	//

	test.Printf( _L("Reading block info...") );

	TLocalDriveCapsV2Buf info;

    iDrive.Caps(info);

	TUint flashSize = I64LOW(info().iSize);

	test( 0 == I64HIGH(info().iSize));

	iBlockSize = info().iEraseBlockSize;

	test( 0 == (iBlockSize & 3) );

	iBlockCount = flashSize / iBlockSize;

	test( 0 != iBlockCount );

	test.Printf( _L("Flash block size=0x%x; block count=%d\n"), iBlockSize, iBlockCount );

	iEraseArray = new(ELeave) TEraseStatus[iBlockCount];

	test.Printf( _L("Erase status array created") );

	}

void CBlockManager::EraseBlock( TInt aBlockNumber )

	{

	__ASSERT_ALWAYS( aBlockNumber < iBlockCount, Panic( EPanicEraseBlockOOR ) );

	__ASSERT_ALWAYS( aBlockNumber < iBlockCount, Panic( EPanicEraseBlockNeg ) );

	_LIT( KEraseMsg, "Erasing block %d" );

	test.Printf( KEraseMsg, aBlockNumber );

	test( KErrNone == iDrive.Format( BlockAddress( aBlockNumber ), iBlockSize ) );

	VerifyErased( aBlockNumber );

	iEraseArray[ aBlockNumber ] = EErased;

	}

void CBlockManager::EraseAllBlocks()

	{

	_LIT( KEraseMsg, "Erasing all blocks" );

	test.Printf( KEraseMsg );

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

		{

		EraseBlock( i );

		}

	}

void CBlockManager::VerifyErased( TInt aBlockNumber )

	{

	TUint offset = aBlockNumber * iBlockSize;

	TBool failed = EFalse;

	const TInt readBufLen = iReadBuffer.MaxLength();

	for( TInt remaining = iBlockSize; remaining > 0 && !failed ;)

		{

		TInt r = iDrive.Read( offset, readBufLen, iReadBuffer );

		if( r != KErrNone )

			{

			test.Printf( _L("... FAIL: read failed (%d) at offset 0x%x\n"), r, offset );

			test( KErrNone == r );

			}

		test( iReadBuffer.Length() == readBufLen );

		const TUint32* p = (const TUint32*)iReadBuffer.Ptr();

		for( TInt i = 0; i < readBufLen; i += 4 )

			{

			if( 0xFFFFFFFF != *p )

				{

				failed = ETrue;

				test.Printf( _L("... FAILED: byte @ offs=0x%x, read=0x%x, expected=0xFF\n"), 

								offset+i, p[0] );

				test(EFalse);

				}

			++p;

			}

		offset += readBufLen;

		remaining -= readBufLen;

		}

	}

void CBlockManager::InitialiseSequentialBlockAllocator()

	//

	// Clears the erase status and resets to block zero

	//

	{

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

		{

		iEraseArray[i] = ENotErased;

		}

	iNextBlock = 0;

	}

TInt CBlockManager::NextErasedBlock()

	{

	if( iNextBlock >= iBlockCount )

		{

		iNextBlock = 0;

		}

	if( ENotErased == iEraseArray[iNextBlock] )

		{

		EraseBlock( iNextBlock );

		}

	iEraseArray[iNextBlock] = ENotErased;	// assume it is going to be used

	return iNextBlock;

	}

void CBlockManager::InitialiseDataChunkAllocator()

	{

	iDataBlock = NextErasedBlock();

	iDataOffset = 0;

	}

TUint CBlockManager::NextErasedDataChunk( TInt aRequiredLength, TInt aMultiple )

	//

	// Request a chunk of erased flash of size aRequiredLength bytes on a

	// boundary of aMultiple bytes. E,g, to allocate a buffer on 12 bytes length

	// on a 32-byte boundary, aRequiredLength = 12, aMultiple=12

	//

	// The byte count is rounded up to a multiple of 4 bytes

	//

	{

	aRequiredLength = (aRequiredLength + 3) & ~0x3;

	TUint chunkBase = ((iDataOffset + aMultiple - 1) / aMultiple) * aMultiple;

	if( chunkBase > (TUint)iBlockSize || chunkBase + aRequiredLength > (TUint)iBlockSize )

		{

		iDataBlock = NextErasedBlock();

		chunkBase = 0;

		}

	iDataOffset = ( chunkBase + aRequiredLength + 3) & ~0x3;

	return BlockAddress( iDataBlock ) + chunkBase;

	}

inline TInt CBlockManager::BlockCount() const

	{

	return iBlockCount;

	}

inline TInt CBlockManager::BlockSize() const

	{

	return iBlockSize;

	}

inline TInt CBlockManager::FlashSize() const

	{

	return iBlockSize * iBlockCount;

	}

inline TUint CBlockManager::BlockAddress( TInt aBlockNumber ) const

	{

	return (TUint)aBlockNumber * (TUint)iBlockSize;

	}

// **********************************************************************

// Implementation of CWriteTest

CWriteTest::~CWriteTest()

	{

	if( iDriveOpened )

		{

		iDrive.Disconnect();

		}

	delete iBlocks;

	delete iSimpleWriter;

	delete iThreadWriter;

	}

void CWriteTest::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 - not 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;

	//

	// Initialise the block manager

	//

	iBlocks = new(ELeave) CBlockManager( iDrive, *this );

	iBlocks->CreateL();

	//

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

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

#endif

	test.Printf( _L("Main thread handle=%d; dummy thread handle=%d"),

		RThread().Handle(), DummyThreadHandle() );

	//

	// Create the writer classes

	//

	iSimpleWriter = new(ELeave) TSimpleWrite( *this );

	iThreadWriter = new(ELeave) TThreadWrite( *this );

	//

	// Seed the pseudo-random number generator

	//

	iRandom.SetSeed( KRandomSeed1 );

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

	}

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

	//

	// Thread does nothing at all

	//

	{

	for(;;)

		{

		User::WaitForAnyRequest();	// just block

		}

	}

void CWriteTest::CreateRandomData( TDes8& aDestBuf, TInt aLength )

	//

	// Fills supplied descriptor with aLength bytes of pseudo-random test data

	//

	{

	aDestBuf.SetLength( aLength );

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

	for( TInt j = aLength/4; j > 0 ; j-- )

		{

		*p++ = iRandom.Next();

		}

	if( aLength & 0x3 )

		{

		TUint8* q = (TUint8*)p;

		for( TInt k = aLength & 3; k > 0; k-- )

			{

			*q++ = (TUint8)iRandom.Next();

			}

		}

	}

TBool CWriteTest::CheckOnes( TUint aFlashOffset, TInt aLength )

	//

	// Checks that aLength bytes of data from offset aFlashOffset

	// all contain 0xFF

	//

	{

	TUint offset = aFlashOffset;

	TBool failed = EFalse;

	const TInt readBufLen = iReadBuffer.MaxLength();

	for( TInt remaining = aLength; remaining > 0 && !failed ;)

		{

		TInt readLen = Min( remaining, readBufLen );

		TInt r = iDrive.Read( offset, readLen, iReadBuffer );

		if( r != KErrNone )

			{

			test.Printf( _L("... FAIL: read failed (%d) at offset 0x%x\n"), r, offset );

			test( KErrNone == r );

			}

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

		const TUint8* p = iReadBuffer.Ptr();

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

			{

			if( 0xFF != *p )

				{

				failed = ETrue;

				test.Printf( _L("... FAILED: byte @ offs=0x%x, read=0x%x, expected=0xFF\n"), 

								offset+i, p[0] );

				break;

				}

			++p;

			}

		offset += readLen;

		remaining -= readLen;

		}

	return !failed;

	}

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

	//

	// Checks that the data in aDes matches that in the Flash at position

	// aFlashOffset.

	// The test starts at offset aDescOffset in aSampleData. aLength bytes

	// are tested.

	//

	{

	__ASSERT_ALWAYS( aDescOffset + aLength <= aDes.Length(), Panic( EPanicCompareDescOverflow ) );

	TInt dataLength = aLength;

	const TUint8* srcPtr = aDes.Ptr() + aDescOffset;

	TUint offset = aFlashOffset;

	TBool failed = EFalse;

	const TInt readBufLen = iReadBuffer.MaxLength();

	while( (dataLength > 0) && !failed )

		{

		TInt len = Min( dataLength, readBufLen );

		TInt r = iDrive.Read( offset, len, iReadBuffer );

		if( r != KErrNone )

			{

			test.Printf( _L("... FAIL: read failed (%d) at offset 0x%x\n"), r, offset );

			test( KErrNone == r );

			}

		test( iReadBuffer.Length() == len );

		if( 0 != Mem::Compare( srcPtr, len, iReadBuffer.Ptr(), len ) )

			{

			test.Printf( _L("... FAIL: mismatch around offset 0x%x\n"), offset );

			failed = ETrue;

			}

		offset += len;

		dataLength -= len;

		srcPtr += len;

		}

	return !failed;

	}

TBool CWriteTest::CompareAgainstFlash( TInt aFlashOffset, const TDesC8& aDes )

	//

	// Checks that the data in aDes matches that in the Flash at position

	// aFlashOffset.

	// aDes->Length() bytes are tested.

	//

	{

	return CompareAgainstFlash( aFlashOffset, aDes.Length(), aDes, 0 );

	}

void CWriteTest::SimpleWriteTest()

	{

	test.Next( _L("Simple write test, simple write function") );

	DoSimpleWriteTest( *iSimpleWriter );

	}

void CWriteTest::SimpleThreadWriteTest()

	{

	test.Next( _L("Simple write test, thread write function") );

	DoSimpleWriteTest( *iThreadWriter );

	}

void CWriteTest::DoSimpleWriteTest( MGeneralizedWrite& aWriter )

	//

	// Writes some random test data to the start of a block, checks that

	// it is written correctly and that the source data isn't modified

	//

	{

	TInt blockNo = iBlocks->NextErasedBlock();

	TUint blockBase = iBlocks->BlockAddress( blockNo );

	TBuf8<512> randomData;

	CreateRandomData( randomData, randomData.MaxLength() );

	TBuf8<512> randomDataDuplicate;

	randomDataDuplicate.Copy( randomData );

	test( randomDataDuplicate == randomData );