// Copyright (c) 2003-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:
// Tests erasing of Flash. Does not test suspending (see TF_SUSPEND)
// 
//

#include <e32std.h>
#include <e32std_private.h>
#include <e32svr.h>
#include <e32test.h>
#include "randgen.h"
#include "user_config.h"

RTest test( _L("TF_ERASE") );


class CEraseTest : public CBase
	{
	public:
		~CEraseTest();

		void CreateL();

		void DoTest();

	private:
		void DoSimpleTest();
		void DoSimpleTest2();
		void DoPseudoRandomTest();
		void DoRangeTest();

		TInt EraseOneBlock( TInt aBlockNumber );
		TInt ZeroFillBlock( TInt aBlockNumber );
		TBool ValidateBlock( TInt aBlockNumber, TUint32 aFillWord );


	private:
		TBusLocalDrive	iDrive;
		TBool			iDriveOpened;

		TInt			iFlashSize;
		TInt			iBlockSize;
		TInt			iBlockCount;

		TBuf8<512>		iReadBuffer;

	};


CEraseTest::~CEraseTest()
	{
	if( iDriveOpened )
		{
		iDrive.Disconnect();
		}
	}



void CEraseTest::CreateL()
	{
	//
	// Load the device drivers
	//
#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 drive
	//
	test.Printf( _L("Opening media channel\n") );
	static TBool changedFlag = EFalse;
	User::LeaveIfError( iDrive.Connect( KDriveNumber, changedFlag ) );
	iDriveOpened = ETrue;

	//
	// Get size of Flash drive, block size, block count
	//
	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 );
	test.Printf( _L("Block size is 0x%x bytes\n"), iBlockSize );
	test.Printf( _L("Block count is %d\n"), iBlockCount );

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


void CEraseTest::DoTest()
	//
	// Main test dispatcher
	//
	{
	test.Next( _L("Starting tests...") );
	DoSimpleTest();
	DoSimpleTest2();
	DoPseudoRandomTest();
	DoRangeTest();
	}


TInt CEraseTest::EraseOneBlock( TInt aBlockNumber )
	//
	// Erases block aBlockNumber on Flash
	//
	{
	TInt blockBaseOffset = aBlockNumber * iBlockSize;

	test.Printf( _L("Erasing block %d (offs=0x%x)\n"), aBlockNumber, blockBaseOffset );
	
	TInt r = iDrive.Format( blockBaseOffset, iBlockSize );

	test.Printf( _L("... Format returned %d\n"), r );
	return r;
	}


TBool CEraseTest::ValidateBlock( TInt aBlockNumber, TUint32 aFillWord )
	//
	// Checks that every word in block aBlockNumber has the value aFillWord
	//
	{
	TUint offset = aBlockNumber * iBlockSize;
	test.Printf( _L("Validating block %d (offs=0x%x)\n"), aBlockNumber, offset );
	
	TBool failed = EFalse;
	const TInt readBufLen = iReadBuffer.MaxLength();

	for( TInt len = iBlockSize; len > 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 );

		TUint32* p = (TUint32*)iReadBuffer.Ptr();
		for( TInt i = 0; i < readBufLen; i += 4 )
			{
			if( aFillWord != *p )
				{
				failed = ETrue;
				test.Printf( _L("... FAILED: word @ offs=0x%x, read=0x%x, expected=0x%x\n"), 
								offset+i, p[0], aFillWord );
				break;
				}
			++p;
			}
		offset += readBufLen;
		len -= readBufLen;
		}
	
	return !failed;
	}


TInt CEraseTest::ZeroFillBlock( TInt aBlockNumber )
	//
	// Zero-fills an entire block
	// The requires that writing works (so as a side-effect performs a
	// very basic test of writing)
	//
	{
	test.Printf( _L("Zero-filling block %d\n"), aBlockNumber );

	//
	// Create a buffer full of zeros
	//
	const TInt KZeroBufSize = 512;

	TBuf8<KZeroBufSize> buf;
	buf.FillZ( buf.MaxLength() );

	//
	// Write the data out to the Flash
	//
	TInt writeCount = iBlockSize / KZeroBufSize;
	TInt r = KErrNone;
	TInt blockBaseOffset = aBlockNumber * iBlockSize;
	for( ; (writeCount > 0) && (KErrNone == r); writeCount-- )
		{
		r = iDrive.Write( blockBaseOffset, buf );
		if( r != KErrNone )
			{
			test.Printf( _L("... FAIL: write failed (%d) at offset 0x%x\n"), r, blockBaseOffset );
			}
		blockBaseOffset += KZeroBufSize;
		}

	return r;
	}


void CEraseTest::DoSimpleTest()
	//
	// Simple erase test. This just zero-fills and then erases each block in turn
	//
	{
	test.Next( _L("Simple test: erases each block in turn\n") );

	for( TInt block = 0; block < iBlockCount; block++ )
		{
		test( KErrNone == ZeroFillBlock( block ) );
		test( ValidateBlock( block, 0 ) );
		test( KErrNone == EraseOneBlock( block ) );
		test( ValidateBlock( block, 0xFFFFFFFF ) );
		}
	}

void CEraseTest::DoSimpleTest2()
	//
	// Another simple erase test.
	// This time we zero-fill all blocks first, then erase them all
	//
	{
	test.Next( _L("Simple test2 : zero-fills whole Flash, then erases all blocks\n") );

	for( TInt block = 0; block < iBlockCount; block++ )
		{
		test( KErrNone == ZeroFillBlock( block ) );
		test( ValidateBlock( block, 0 ) );
		}

	for( TInt block = 0; block < iBlockCount; block++ )
		{
		test( KErrNone == EraseOneBlock( block ) );
		test( ValidateBlock( block, 0xFFFFFFFF ) );
		}
	}



void CEraseTest::DoPseudoRandomTest()
	//
	// Erases the blocks in pseudo-random order, zero-filling first
	//
	{
	test.Next( _L("Test random erase order\n") );

	TRandomGenerator random;
#if 0
	random.SetSeed( TInt64(0x1020466E, 0x3F9C0C00) );
#else
	random.SetSeed( 0x1020466E );
#endif

	for( TInt count = 0; count < 50; count++ )
		{
		TUint block = random.Next() % iBlockCount;
		test( KErrNone == ZeroFillBlock( block ) );

		test( ValidateBlock( block, 0 ) );

		test( KErrNone == EraseOneBlock( block ) );

		test( ValidateBlock( block, 0xFFFFFFFF ) );
		}
	}

void CEraseTest::DoRangeTest()
	//
	// Simple erase test. This just zero-fills and then erases each block in turn
	//
	{
	test.Next( _L("Range test: check that erase only affects erased block\n") );

	//
	// Pre-fill all blocks with zero
	//
	test.Printf( _L("Pre-zeroing blocks\n") );
	for( TInt block = 0; block < iBlockCount; block++ )
		{
		test( KErrNone == ZeroFillBlock( block ) );
		test( ValidateBlock( block, 0 ) );
		}

	//
	// The test is to erase a block. Check it is erased and all
	// other blocks are still zeros. Then we re-zero the block just
	// erased and repeat test with next block
	//
	test.Printf( _L("Now testing erase...\n") );
	for( TInt eraseBlock = 0; eraseBlock < iBlockCount; eraseBlock++ )
		{
		test( KErrNone == EraseOneBlock( eraseBlock ) );
		test( ValidateBlock( eraseBlock, 0xFFFFFFFF ) );
		
		// check all other blocks are still zero
		for( TInt j = 0; j < iBlockCount; j++ )
			{
			if( j != eraseBlock )
				{
				// test if not the one we just erased
				test( ValidateBlock( j, 0 ) );
				}
			}

		// Now zero-fill the block we just erased and move to next block
		test( KErrNone == ZeroFillBlock( eraseBlock ) );
		test( ValidateBlock( eraseBlock, 0 ) );
		}

	}


TInt E32Main()
	{
	test.Title();
	test.Start(_L("Testing media erase operations"));

	CEraseTest eraseTest;
	TRAPD( ret, eraseTest.CreateL() );
	if( KErrNone == ret )
		{
		eraseTest.DoTest();
		}

	test.End();
	return KErrNone;
	}