diff -r 000000000000 -r 96e5fb8b040d kerneltest/f32test/server/t_blockmap.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_blockmap.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1404 @@
+// 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 <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);
+	test( r == KErrNone );
+
+	TInt localDriveNum = 0;
+	RFile testFile;
+	r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	
+	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);
+			test( r == KErrNone );
+			r = fMan->Delete(name);
+			test( r == KErrNone );
+			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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					amountRead += miniLength;
+					length -= miniLength;
+					miniLength = 0;
+					}
+				} while ( miniLength != 0 && length != 0);
+			myBlockMapEntry++;
+			}
+		}
+	map.Close();
+
+	testFile.Close();
+	r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+	test( r == KErrNone );
+	r = fMan->Delete(name);
+	test( r == KErrNone );
+	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 );
+	test( r == KErrNone );
+	
+	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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					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 );
+	test( r == KErrNone );
+	
+	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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					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);
+	test( r == KErrNone  || r == KErrAlreadyExists);
+
+	TInt localDriveNum = 0;
+	RFile testFile;
+	r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	
+	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);
+			test( r == KErrNone );
+			r = fMan->Delete(name);
+			test( r == KErrNone );
+			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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					amountRead += miniLength;
+					length -= miniLength;
+					miniLength = 0;
+					}
+				} while ( miniLength != 0 && length != 0);
+			myBlockMapEntry++;
+			}
+		}
+	map.Close();
+
+	testFile.Close();
+	r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+	test( r == KErrNone );
+	r = fMan->Delete(name);
+	test( r == KErrNone );
+	delete fMan;
+	return bmErr;
+	}
+
+LOCAL_C TInt TestBlockMapRamFAT2(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);
+	test( r == KErrNone  || r == KErrAlreadyExists);
+
+	RFile testFile;
+	r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	
+	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;
+	SBlockMapInfo info;
+
+	TInt bmErr;
+	bmErr = testFile.BlockMap(info, aStartPos, aEndPos, EBlockMapUsagePaging);
+
+	map.Close();
+
+	testFile.Close();
+	r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+	test( r == KErrNone );
+	r = fMan->Delete(name);
+	test( r == KErrNone );
+	delete fMan;
+	return bmErr;
+	}
+
+LOCAL_C TInt TestBlockMapRemovableFAT(TInt64 aStartPos, TInt64 aEndPos)
+//
+// Test BlockMap retrieval on Removable FAT.
+//
+	{
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	TFileName name(KDriveBase);
+	name[0] = TText('A' + RemovableFatDrive);
+	name.Append( KTestFileName );
+
+	TInt r=fMan->Copy(KTestFile, name);
+	test( r == KErrNone  || r == KErrAlreadyExists);
+
+	RFile testFile;
+	r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	
+	RArray<SBlockMapInfo> map;	// From RArray<TBlockMapEntry> map; to RArray<SBlockMapInfo> map;
+	SBlockMapInfo info;
+	TInt bmErr = testFile.BlockMap(info, aStartPos, aEndPos, Pageable?EBlockMapUsagePaging:ETestDebug);
+	map.Close();
+
+	testFile.Close();
+	r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+	test( r == KErrNone );
+	r = fMan->Delete(name);
+	test( r == KErrNone );
+	delete fMan;
+	return bmErr;
+	}
+
+LOCAL_C TInt TestBlockMapInternalRemovableFAT(TInt64 aStartPos, TInt64 aEndPos)
+//
+// Test BlockMap retrieval on internal removable FAT.
+//
+	{
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	TFileName name(KDriveBase);
+	name[0] = TText('A' + RamFatDrive);
+	name.Append( KTestFileName );
+
+	TInt r=fMan->Copy(KTestFile, name);
+	test( r == KErrNone  || r == KErrAlreadyExists);
+
+	TInt localDriveNum = 0;
+	RFile testFile;
+	r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	
+	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);
+			test( r == KErrNone );
+			r = fMan->Delete(name);
+			test( r == KErrNone );
+			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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					amountRead += miniLength;
+					length -= miniLength;
+					miniLength = 0;
+					}
+				} while ( miniLength != 0 && length != 0);
+			myBlockMapEntry++;
+			}
+		}
+	map.Close();
+
+	testFile.Close();
+	r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+	test( r == KErrNone );
+	r = fMan->Delete(name);
+	test( r == KErrNone );
+	delete fMan;
+	return bmErr;
+	}
+
+LOCAL_C TInt TestBlockMapFragmented(DriveType aDriveType, TInt64 aStartPos, TInt64 aEndPos)
+	{
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	TFileName name(KDriveBase);
+	if (aDriveType==EDriveRam)
+		name[0] = TText('A' + RamFatDrive);
+	else if (aDriveType==EDriveRemovable)
+		name[0] = TText('A' + RemovableFatDrive);
+	else if (aDriveType==EDriveNand)
+		name[0] = TText('A' + NandDrive);
+	else 
+		name[0] = TText('A' + InternalRemovableFatDrive);
+	name.Append( KFragmentedFileName1 );
+	TInt localDriveNum = 0;
+	RFile testFile;
+	TInt r = testFile.Open( TheFs, name, EFileRead );
+	test( r == KErrNone );
+	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();
+			if ( Finished )
+				{
+				r = fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+				test( r == KErrNone );
+				r = fMan->Delete(name);
+				test( r == KErrNone );
+				}
+			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);
+	test( r == KErrNone );
+
+	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 );
+	test( r == KErrNone );
+
+//	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 );
+					test( r == 0 );
+					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 );
+					test( r == 0 );
+					amountRead += miniLength;
+					length -= miniLength;
+					miniLength = 0;
+					}
+				} while ( miniLength != 0 && length != 0);
+			myBlockMapEntry++;
+			}
+		}
+	map.Close();
+
+	testFile.Close();
+	if ( Finished )
+		{
+		r=fMan->Attribs(name, 0, KEntryAttReadOnly, 0);
+		test( r == KErrNone );
+		r = fMan->Delete(name);
+		test( r == KErrNone );
+		}
+	delete fMan;
+	return bmErr;	
+	}
+
+LOCAL_C void GenerateFragmentedFiles(DriveType aDriveType)
+	{
+	TInt r;
+	TFileName name1(KDriveBase);
+	if (aDriveType==EDriveRam)
+		name1[0] = TText('A' + RamFatDrive);
+	else if (aDriveType==EDriveRemovable)
+		name1[0] = TText('A' + RemovableFatDrive);
+	else if (aDriveType==EDriveNand)
+		name1[0] = TText('A' + NandDrive);
+	else 
+		name1[0] = TText('A' + InternalRemovableFatDrive);
+	name1.Append( KFragmentedFileName1 );
+	RFile file1;
+	r = file1.Create(TheFs, name1, EFileWrite);
+	test( r == KErrNone );
+	file1.Close();
+
+	TFileName name2(KDriveBase);
+	if (aDriveType==EDriveRam)
+		name2[0] = TText('A' + RamFatDrive);
+	else if (aDriveType==EDriveRemovable)
+		name2[0] = TText('A' + RemovableFatDrive);
+	else if (aDriveType==EDriveNand)
+		name2[0] = TText('A' + NandDrive);
+	else 
+		name2[0] = TText('A' + InternalRemovableFatDrive);
+	name2.Append( KFragmentedFileName2 );
+	RFile file2;
+	r = file2.Create(TheFs, name2, EFileWrite);
+	test( r == KErrNone );
+	file2.Close();
+	TInt64 randomSeed;
+	TBuf8<KMaxFragmentSize> tempBuf;	
+	TUint8 *buf;
+	TInt fileSize = 0;
+	TInt fragmentSize;
+	TInt randomLength;
+	TInt pos1;
+	TInt pos2;
+	TInt mycount = 0;
+	do	
+		{
+		fragmentSize = 0;
+		pos1 = 0;
+		pos2 = 0;
+		buf = (TUint8*) tempBuf.Ptr();
+		tempBuf.Zero();
+		randomLength = Math::Random() % KMaxFragmentSize;
+		randomSeed = Math::Random();
+		tempBuf.SetLength(randomLength);
+
+		while (randomLength-- && fragmentSize++ < KMaxFragmentSize && fileSize++ < KMaxFileSize)
+			{
+			*buf++ = (TUint8)('A' + (Math::Rand(randomSeed) % ('Z' - 'A')));
+			}
+		r = file1.Open( TheFs, name1, EFileWrite );
+		test( r == KErrNone );
+		r = file1.Seek( ESeekEnd, pos1 );
+		test( r == KErrNone );
+		r = file1.Write( pos1, tempBuf );
+		test( r == KErrNone );
+		r = file1.Flush();
+		test( r == KErrNone );		
+		file1.Close();
+		if ( mycount++ < 6 )
+			{
+			r = file2.Open( TheFs, name2, EFileWrite );
+			test( r == KErrNone );
+			r = file2.Seek( ESeekEnd, pos2 );
+			test( r == KErrNone );
+			r = file2.Write( pos2, tempBuf );
+			test( r == KErrNone );
+			r = file2.Flush();
+			test( r == KErrNone );
+			file2.Close();
+			}
+		} while ( fileSize < KMaxFileSize );
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	r = fMan->Delete(name2);
+	test( r == KErrNone );
+	delete fMan;
+	}
+
+LOCAL_C void FindDrive(DriveType aDriveType)
+	{
+	TInt i;
+	TInt c = 0;
+	for( i = EDriveA; i < EDriveZ; i++ )
+		{
+		TDriveInfo info;
+		TInt r = TheFs.Drive(info, i);
+		if ( r != KErrNone )
+			continue;
+		test( r == KErrNone );
+		if ( aDriveType == EDriveNand )	
+			{
+			c++ == 0 ? test.Printf( _L("Searching for NAND drive.")) : test.Printf( _L("."));
+			if ( info.iType == EMediaNANDFlash && ((info.iMediaAtt & KMediaAttWriteProtected) == 0) )
+				{
+				if ( info.iDriveAtt & KDriveAttPageable )
+					Pageable = ETrue;
+				NandDrive = i;
+				test.Printf( _L("Found NAND drive: %d\n"), NandDrive );
+				break;
+				}
+			}
+		else if ( aDriveType == EDriveRam )
+			{
+			c++ == 0 ? test.Printf( _L("Searching for RAM FAT drive.")) : test.Printf( _L("."));
+			if ( (info.iType == EMediaRam) && ( info.iDriveAtt == (KDriveAttLocal|KDriveAttInternal) ) && ( info.iMediaAtt == (KMediaAttVariableSize|KMediaAttFormattable) ) )
+				{
+				if ( info.iDriveAtt & KDriveAttPageable )
+					Pageable = ETrue;
+				RamFatDrive = i;
+				test.Printf( _L("Found RAM FAT drive: %d\n"), RamFatDrive );
+				break;
+				}
+			}
+		else if ( aDriveType == EDriveRemovable )
+			{
+			c++ == 0 ? test.Printf( _L("Searching for removable FAT drive.")) : test.Printf( _L("."));
+			if ( info.iType == EMediaHardDisk && ( info.iDriveAtt == (KDriveAttLocal|KDriveAttRemovable) ) )
+				{
+				if ( info.iDriveAtt & KDriveAttPageable )
+					Pageable = ETrue;
+				RemovableFatDrive = i;
+				test.Printf( _L("Found removable FAT drive: %d\n"), RemovableFatDrive );
+				break;
+				}
+			}
+		else if ( aDriveType == EDriveInternalRemovable )
+			{
+			c++ == 0 ? test.Printf( _L("Searching for internal removable FAT drive.")) : test.Printf( _L("."));
+			if ( info.iType == EMediaHardDisk && ( info.iDriveAtt == (KDriveAttLocal|KDriveAttInternal) ) )
+				{
+				if ( info.iDriveAtt & KDriveAttPageable )
+					Pageable = ETrue;
+				InternalRemovableFatDrive = i;
+				test.Printf( _L("Found internal removable FAT drive: %d\n"), InternalRemovableFatDrive );
+				break;
+				}
+			}
+		}
+		if ( i == EDriveZ )
+			{
+			switch(aDriveType)
+				{
+				case EDriveNand:
+					test.Printf( _L("NAND drive not found.\n") );
+					break;
+				case EDriveRam:
+					test.Printf( _L("RAM FAT drive not found.\n") );
+					break;
+				case EDriveRemovable:
+					test.Printf( _L("Removable FAT drive not found.\n") );
+					break;
+				case EDriveInternalRemovable:
+					test.Printf( _L("Internal removable FAT drive not found.\n") );
+					break;
+				default:
+					test.Printf( _L("Drive not found.\n") );
+				}			
+			}
+	}
+
+//************************
+// Entry point
+
+GLDEF_C void CallTestsL(void)
+	{
+	test.Title(); 
+	test.Start( _L("BlockMap Test\n") );
+
+	TInt testFileSize = 0;
+	RFile testFile;
+	TInt r = testFile.Open(TheFs, KTestFile, EFileRead);
+	test(r==KErrNone);
+	r = testFile.Size(testFileSize);
+	test(r==KErrNone);
+	test(testFileSize>16384);
+	testFile.Close();
+
+	if ( gDriveToTest == 'C' )
+		{
+		TInt value;
+		r = HAL::Get( HAL::EMachineUid, value );
+		test( r == KErrNone );
+		if ( value != HAL::EMachineUid_Lubbock )	// Lubbock cannot run FindDrive as it doesn't support the NAND API
+			{
+			test.Next(_L("Test BlockMap retrieval on NAND FAT."));
+			FindDrive(EDriveNand);
+			if ( NandDrive > -1 )	// not finding a NAND drive isn't an error as only NAND builds have one
+				{
+				r = TestBlockMapNandFATUserData(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(1024, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(-5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(-5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFATUserData(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(2000, 2000);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFATUserData(2048, 2048);
+				test( r == KErrArgument );
+				test.Printf(_L("Generating Fragmented File..."));
+				GenerateFragmentedFiles(EDriveNand);
+				test.Printf(_L("Done!\n"));
+				test.Next(_L("Test BlockMap retrieval on NAND FAT (User area) (fragmented)."));	
+				r = TestBlockMapFragmented(EDriveNand, 0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 1024, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, -5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, -5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, 0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, 0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveNand, 0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveNand, 2000, 2000);
+				test( r == KErrArgument );
+				Finished = ETrue;
+				r = TestBlockMapFragmented(EDriveNand, 2048, 2048);
+				test( r == KErrArgument );
+				test.Next(_L("Test BlockMap retrieval on NAND FAT."));	
+				r = TestBlockMapNandFAT(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(1024, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(-5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(-5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandFAT(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(2000, 2000);
+				test( r == KErrArgument );
+				r = TestBlockMapNandFAT(2048, 2048);
+				test( r == KErrArgument );
+				test.Next(_L("Test BlockMap retrieval on NAND ROFS."));
+				r = TestBlockMapNandROFS(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(1024, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(-5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(-5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapNandROFS(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(2000, 2000);
+				test( r == KErrArgument );
+				r = TestBlockMapNandROFS(2048, 2048);
+				test( r == KErrArgument );
+				test.Next(_L("Test BlockMap retrieval on RAM FAT."));
+				FindDrive(EDriveRam);
+				test( RamFatDrive > -1 );
+				r = TestBlockMapRamFAT(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(1024, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(-5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(-5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapRamFAT(0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(2000, 2000);
+				test( r == KErrArgument );
+				r = TestBlockMapRamFAT(2048, 2048);
+				test( r == KErrArgument ); 
+				test.Next(_L("Test BlockMap retrieval on Ram FAT (2)."));
+				r = TestBlockMapRamFAT2(0, -1);
+				test( r == KErrNotSupported );
+				FindDrive(EDriveRemovable);
+				if ( RemovableFatDrive > -1)
+					{
+					test.Next(_L("Test BlockMap retrieval on removable FAT."));
+					r = TestBlockMapRemovableFAT(0, -1);
+					Pageable?test( r == KErrNotSupported ):test( r == KErrCompletion );
+					}
+				else
+					{
+					test.Next(_L("Test BlockMap retrieval on internal removable FAT."));
+					FindDrive(EDriveInternalRemovable);
+					test( InternalRemovableFatDrive > -1);
+					r = TestBlockMapInternalRemovableFAT(0, -1);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(1024, 4096);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(1020, 4100);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(1024, 4100);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(1020, 4096);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(1025, 1200);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(0, testFileSize+100);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(-5, -1);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(-5, testFileSize+100);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(0, 0);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(testFileSize, -1);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(0, -1);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(2000, 2001);
+					test( r == KErrCompletion );
+					r = TestBlockMapInternalRemovableFAT(0, 0);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(2000, 2000);
+					test( r == KErrArgument );
+					r = TestBlockMapInternalRemovableFAT(2048, 2048);
+					test( r == KErrArgument );
+					}
+				test.Next(_L("Test BlockMap retrieval on Ram FAT (fragmented)."));	
+				test.Printf(_L("Generating Fragmented File..."));
+				GenerateFragmentedFiles(EDriveRam);
+				test.Printf(_L("Done!\n"));
+				Finished = EFalse;
+				r = TestBlockMapFragmented(EDriveRam, 0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 1020, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 2049, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 1024, 4100);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 1020, 4096);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 1025, 1200);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 0, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, -5, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, -5, testFileSize+100);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, 0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, testFileSize, -1);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, 0, -1);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 2000, 2001);
+				test( r == KErrCompletion );
+				r = TestBlockMapFragmented(EDriveRam, 0, 0);
+				test( r == KErrArgument );
+				r = TestBlockMapFragmented(EDriveRam, 2000, 2000);
+				test( r == KErrArgument );
+				Finished = ETrue;
+				r = TestBlockMapFragmented(EDriveRam, 2048, 2048);
+				test( r == KErrArgument );
+				}
+			else
+				{
+				test.Printf( _L("NAND drive not found, skipping test.\n") );
+				}
+			}
+		}
+	test.End();
+	test.Close();
+	}