// Copyright (c) 2006-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 for the blockmap API. The blockmap API enumerates the resources

// used by a file depending upon the type of media on which the file

// resides.

// 002 Test Initialise error checking

// 003 Test processing of user-side block map into extent list

// 004 Test processing of user-side block map into extent list, block size > read unit size

// 005 Test Read error checking

// 006 Test Read

// Test BlockMap API functionality.

// 

//

//! @SYMTestCaseID			KBASE-T_BLOCKMAP-0337

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Blockmap tests

//! @SYMTestActions			001 Unit tests the TKernBlockMap class

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#include <e32test.h>

#include <e32svr.h>

#include <f32file.h>

#include <e32math.h>

#include <hal.h>

#include "t_server.h"

RTest test( _L("T_BLOCKMAP") );

const TInt KReadBufferSize = 1024;

const TInt KMaxFragmentSize = 400;

const TInt KMaxFileSize = 10000;

TInt RamFatDrive = -1;

TInt RemovableFatDrive = -1;

TInt InternalRemovableFatDrive = -1;

TInt NandDrive = -1;

TBool Pageable = EFalse;

TBool Finished = EFalse;

enum DriveType

	{

	EDriveNand,

	EDriveRam,

	EDriveRemovable,

	EDriveInternalRemovable

	};

_LIT( KTestFile, "Z:\\TEST\\T_FILE.CPP");

_LIT( KTestFileFAT, "Z:\\Multiple\\T_file.cpp");

_LIT( KTestFileName, "T_FILE.CPP");

_LIT( KFragmentedFileName1, "FRAG1.TXT");

_LIT( KFragmentedFileName2, "FRAG2.TXT");

_LIT( KDriveBase, " :\\" );

LOCAL_C TInt TestBlockMapNandFATUserData(TInt64 aStartPos, TInt64 aEndPos)

	{

	CFileMan* fMan=CFileMan::NewL(TheFs);

	test(fMan!=NULL);

	TFileName name(KDriveBase);

	name[0] = TText('A' + NandDrive);

	name.Append( KTestFileName );

	TInt r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);

	r = fMan->Delete(name);

	r = fMan->Copy(KTestFile, name);

	TInt localDriveNum = 0;

	RFile testFile;

	r = testFile.Open( TheFs, name, EFileRead );

	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;

	SBlockMapInfo info;

	TInt counter = 0;

	TInt startPos = aStartPos;

	TInt bmErr;

	// Store SBlockMapInfo objects in map:RArray until KErrCompletion is returned.

	do

		{

		bmErr = testFile.BlockMap(info, aStartPos, aEndPos, ETestDebug);

		if (bmErr != 0 && bmErr != KErrCompletion)

			{

			map.Close();

			testFile.Close();

			r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);

			r = fMan->Delete(name);

			delete fMan;

			return bmErr;

			}

		map.Append(info); 

		if (counter++ == 0)

			localDriveNum = info.iLocalDriveNumber;

		} while ( bmErr == 0 && bmErr != KErrCompletion );

	test( bmErr == KErrCompletion );

	TInt granularity;

	TInt size;

	r = testFile.Size(size);

	TBuf8<KReadBufferSize> buf1;

	TBuf8<KReadBufferSize> buf2;

	TBool changed;	

	TBusLocalDrive localDrive;

	UserSvr::UnlockRamDrive();

	TBlockMapEntry* myBlockMapEntry;

	TInt myCounter = 0;

	TInt totalSegments = 0;

	TInt remainder = 0;

	TInt miniLength = 0;

	TInt amountRead = 0;

	TInt c;

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		totalSegments += granularity;

		}

	const TInt KTotalSegments = totalSegments;

	r = localDrive.Connect( localDriveNum, changed );

//	For each SBlockMapInfo object in RArray map

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		TInt length;

		if ( aEndPos == -1 )

			{

			length = size - startPos;

			aEndPos = size;

			}

		else

			length = aEndPos - startPos;

		for ( TInt c2 = 1; c2 <= granularity; c2++)

			{

			myCounter = 0;

			if ( c2 == KTotalSegments && aEndPos%map[c].iBlockGranularity != 0 )

				remainder = map[c].iBlockGranularity - aEndPos%map[c].iBlockGranularity;

			else

				remainder = 0;

			miniLength = map[c].iBlockGranularity*myBlockMapEntry->iNumberOfBlocks - remainder - (c2 == 1?map[c].iBlockStartOffset:0);

			do

				{

				if ( miniLength >= KReadBufferSize )

					{

					testFile.Read( startPos + amountRead, buf1, KReadBufferSize );

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, KReadBufferSize, buf2);

					r = buf1.Compare( buf2 );

					buf1.Zero();

					buf2.Zero();

					myCounter++;

					miniLength -= KReadBufferSize;

					length -= KReadBufferSize;

					amountRead += KReadBufferSize;

					}

				else

					{

					testFile.Read(startPos + amountRead, buf1, miniLength);

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, miniLength, buf2);

					r = buf1.Compare( buf2 );

					amountRead += miniLength;

					length -= miniLength;

					miniLength = 0;

					}

				} while ( miniLength != 0 && length != 0);

			myBlockMapEntry++;

			}

		}

	map.Close();

	testFile.Close();

	r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);

	r = fMan->Delete(name);

	delete fMan;

	return bmErr;

	}

LOCAL_C TInt TestBlockMapNandFAT(TInt64 aStartPos, TInt64 aEndPos)

//

// Test BlockMap retrieval on NAND FAT.

//

	{

	TInt localDriveNum = 0;

	RFile testFile;

	TInt r = testFile.Open( TheFs, KTestFileFAT, EFileRead );

	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;

	SBlockMapInfo info;

	TInt counter = 0;

	TInt startPos = aStartPos;

	TInt bmErr;

	// Store SBlockMapInfo objects in map:RArray until KErrCompletion is returned.

	do

		{

		bmErr = testFile.BlockMap(info, aStartPos, aEndPos, Pageable?EBlockMapUsagePaging:ETestDebug);

		if (bmErr != 0 && bmErr != KErrCompletion)

			{

			map.Close();

			testFile.Close();

			return bmErr;

			}

		map.Append(info); 

		if (counter++ == 0)

			localDriveNum = info.iLocalDriveNumber;

		} while ( bmErr == 0 && bmErr != KErrCompletion );

	test( bmErr == KErrCompletion );

	TInt granularity;

	TInt size;

	r = testFile.Size(size);

	TBuf8<KReadBufferSize> buf1;

	TBuf8<KReadBufferSize> buf2;

	TBool changed;	

	TBusLocalDrive localDrive;

	TBlockMapEntry* myBlockMapEntry;

	TInt myCounter = 0;

	TInt totalSegments = 0;

	TInt remainder = 0;

	TInt miniLength = 0;

	TInt amountRead = 0;

	TInt c;

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		totalSegments += granularity;

		}

	const TInt KTotalSegments = totalSegments;

	r = localDrive.Connect( localDriveNum, changed );

//	For each SBlockMapInfo object in RArray map

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		TInt length;

		if ( aEndPos == -1 )

			{

			length = size - startPos;

			aEndPos = size;

			}

		else

			length = aEndPos - startPos;

		for ( TInt c2 = 1; c2 <= granularity; c2++)

			{

			myCounter = 0;

			if ( c2 == KTotalSegments && aEndPos%map[c].iBlockGranularity != 0 )

				remainder = map[c].iBlockGranularity - aEndPos%map[c].iBlockGranularity;

			else

				remainder = 0;

			miniLength = map[c].iBlockGranularity*myBlockMapEntry->iNumberOfBlocks - remainder - (c2 == 1?map[c].iBlockStartOffset:0);

			do

				{

				if ( miniLength >= KReadBufferSize )

					{

					testFile.Read( startPos + amountRead, buf1, KReadBufferSize );

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, KReadBufferSize, buf2);

					r = buf1.Compare( buf2 );

					buf1.Zero();

					buf2.Zero();

					myCounter++;

					miniLength -= KReadBufferSize;

					length -= KReadBufferSize;

					amountRead += KReadBufferSize;

					}

				else

					{

					testFile.Read(startPos + amountRead, buf1, miniLength);

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, miniLength, buf2);

					r = buf1.Compare( buf2 );

					amountRead += miniLength;

					length -= miniLength;

					miniLength = 0;

					}

				} while ( miniLength != 0 && length != 0);

			myBlockMapEntry++;

			}

		}

	map.Close();

	testFile.Close();

	return bmErr;

	}

LOCAL_C TInt TestBlockMapNandROFS(TInt64 aStartPos, TInt64 aEndPos)

//

// Test BlockMap retrieval on NAND ROFS.

//

	{

	TInt localDriveNum = 0;

	RFile testFile;

	TInt r = testFile.Open( TheFs, KTestFile, EFileRead );

	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;

	SBlockMapInfo info;

	TInt counter = 0;

	TInt startPos = aStartPos;

	TInt bmErr;

	// Store SBlockMapInfo objects in map:RArray until KErrCompletion is returned.

	do

		{

		bmErr = testFile.BlockMap(info, aStartPos, aEndPos, Pageable?EBlockMapUsagePaging:ETestDebug);

		if (bmErr != 0 && bmErr != KErrCompletion)

			{

			map.Close();

			testFile.Close();

			return bmErr;

			}

		map.Append(info); 

		if (counter++ == 0)

			localDriveNum = info.iLocalDriveNumber;

		} while ( bmErr == 0 && bmErr != KErrCompletion );

	test( bmErr == KErrCompletion );

	TInt granularity;

	TInt size;

	r = testFile.Size(size);

	TBuf8<KReadBufferSize> buf1;

	TBuf8<KReadBufferSize> buf2;

	TBool changed;	

	TBusLocalDrive localDrive;

	TBlockMapEntry* myBlockMapEntry;

	TInt myCounter = 0;

	TInt totalSegments = 0;

	TInt miniLength = 0;

	TInt amountRead = 0;

	TInt c;

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		totalSegments += granularity;

		}

	r = localDrive.Connect( localDriveNum, changed );

//	For each SBlockMapInfo object in RArray map

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		TInt length;

		if ( aEndPos == -1 )

			{

			length = size - startPos;

			aEndPos = size;

			}

		else

			length = aEndPos - startPos;

		for ( TInt c2 = 1; c2 <= granularity; c2++)

			{

			myCounter = 0;

			miniLength = length;

			do

				{

				if ( miniLength >= KReadBufferSize )

					{

					testFile.Read( startPos + amountRead, buf1, KReadBufferSize );

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, KReadBufferSize, buf2);

					r = buf1.Compare( buf2 );

					buf1.Zero();

					buf2.Zero();

					myCounter++;

					miniLength -= KReadBufferSize;

					length -= KReadBufferSize;

					amountRead += KReadBufferSize;

					}

				else

					{

					testFile.Read(startPos + amountRead, buf1, miniLength);

					localDrive.Read( map[c].iStartBlockAddress + myBlockMapEntry->iStartBlock * map[c].iBlockGranularity + (c2 == 1?map[c].iBlockStartOffset:0) + myCounter*KReadBufferSize, miniLength, buf2);

					r = buf1.Compare( buf2 );

					amountRead += miniLength;

					length -= miniLength;

					miniLength = 0;

					}

				} while ( miniLength != 0 && length != 0);

			myBlockMapEntry++;

			}

		}

	map.Close();

	testFile.Close();

	return bmErr;

	}

LOCAL_C TInt TestBlockMapRamFAT(TInt64 aStartPos, TInt64 aEndPos)

//

// Test BlockMap retrieval on RAM FAT.

//

	{

	CFileMan* fMan=CFileMan::NewL(TheFs);

	test(fMan!=NULL);

	TFileName name(KDriveBase);

	name[0] = TText('A' + RamFatDrive);

	name.Append( KTestFileName );

	TInt r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);

	r = fMan->Delete(name);

	r = fMan->Copy(KTestFile, name);

	TInt localDriveNum = 0;

	RFile testFile;

	r = testFile.Open( TheFs, name, EFileRead );

	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;

	SBlockMapInfo info;

	TInt counter = 0;

	TInt startPos = aStartPos;

	TInt bmErr;

	// Store SBlockMapInfo objects in map:RArray until KErrCompletion is returned.

	do

		{

		bmErr = testFile.BlockMap(info, aStartPos, aEndPos, ETestDebug);

		if (bmErr != 0 && bmErr != KErrCompletion)

			{

			map.Close();

			testFile.Close();

			r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);

			r = fMan->Delete(name);

			delete fMan;

			return bmErr;

			}

		map.Append(info); 

		if (counter++ == 0)

			localDriveNum = info.iLocalDriveNumber;

		} while ( bmErr == 0 && bmErr != KErrCompletion );

	test( bmErr == KErrCompletion );

	TInt granularity;

	TInt size;

	r = testFile.Size(size);

	TBuf8<KReadBufferSize> buf1;

	TBuf8<KReadBufferSize> buf2;

	TBool changed;	

	TBusLocalDrive localDrive;

	UserSvr::UnlockRamDrive();

	TBlockMapEntry* myBlockMapEntry;

	TInt myCounter = 0;

	TInt totalSegments = 0;

	TInt remainder = 0;

	TInt miniLength = 0;

	TInt amountRead = 0;

	TInt c;

	for ( c = 0; c < map.Count(); c++ )

		{

		myBlockMapEntry = (TBlockMapEntry*) map[c].iMap.Ptr();

		granularity = map[c].iMap.Size()/sizeof(TBlockMapEntry);

		totalSegments += granularity;

		}

	const TInt KTotalSegments = totalSegments;

	r = localDrive.Connect( localDriveNum, changed );