// 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:
// e32test\mmu\t_kblockmap.cpp
// Unit tests for TKernBlockMap
// 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
// 
//

//! @SYMTestCaseID			KBASE-T_KBLOCKMAP-0338
//! @SYMTestType			UT
//! @SYMPREQ				PREQ1110
//! @SYMTestCaseDesc		Demand Paging Kernel Blockmap tests
//! @SYMTestActions			001 Unit tests the TKernBlockMap class
//! @SYMTestExpectedResults All tests should pass.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented

#include <e32test.h>
#include <e32debug.h>
#include <memmodel/epoc/mmubase/kblockmap.h>

RTest test(_L("T_KBLOCKMAP"));

#define test_noError(x) { TInt _r = (x); if (_r < 0) HandleError(_r, __LINE__); }
#define test_notNull(x) { TAny* _a = (TAny*)(x); if (_a == NULL) HandleNull(__LINE__); }
#define test_equal(e, a) { TInt _e = (e); TInt _a = (a); if (_e != _a) HandleNotEqual(_e, _a, __LINE__); }

void HandleError(TInt aError, TInt aLine)
	{
	test.Printf(_L("Error %d\n"), aError);
	test.operator()(EFalse, aLine);
	}

void HandleNull(TInt aLine)
	{
	test.Printf(_L("Null value\n"));
	test.operator()(EFalse, aLine);
	}

void HandleNotEqual(TInt aExpected, TInt aActual, TInt aLine)
	{
	test.Printf(_L("Expected 0x%x but got 0x%x\n"), aExpected, aActual);
	test.operator()(EFalse, aLine);
	}

/// An list of "pod" objects which can be initialised by passing a variable number of TUints to its
/// constructor
template <class T>
class CList
	{
public:
	CList();
	CList(TInt aCount, ...);
	virtual ~CList();
	inline TInt Count() const { return iCount; }
	const T* Entries() const { return iEntries; }
	const T& operator[](TInt aIndex) const;
protected:
	void Set(TInt aCount, VA_LIST aList);
private:
	const CList<T>& operator=(const CList<T>&);
	TInt iCount;
	T* iEntries;
	};

template <class T>
CList<T>::CList()
	: iCount(0), iEntries(NULL)
	{
	__ASSERT_COMPILE(sizeof(T) % sizeof(TUint32) == 0);
	}

template <class T>
CList<T>::CList(TInt aCount, ...)
	: iCount(aCount)
	{
	VA_LIST list;
	VA_START(list, aCount);
	Set(aCount, list);
	}

template <class T>
CList<T>::~CList()
	{
	User::Free(iEntries);
	iEntries = NULL;
	}

template <class T>
void CList<T>::Set(TInt aCount, VA_LIST aList)
	{
	iCount = aCount;
	test(iEntries == NULL);
	iEntries = (T*)User::Alloc(sizeof(T) * iCount);
	test_notNull(iEntries);
	TInt argCount = iCount * (sizeof(T) / sizeof(TUint32));
	for (TInt i = 0 ; i < argCount ; ++i)
		((TUint32*)iEntries)[i] = VA_ARG(aList, TUint32);
	}

template <class T>
const T& CList<T>::operator[](TInt aIndex) const
	{
	test(aIndex < iCount);
	return iEntries[aIndex];
	}

/// Holds all the data associated with the user-side representation of a block map
class CBlockMap : public CList<TBlockMapEntryBase>
	{
public:
	CBlockMap(TUint aBlockGranularity,
			  TUint aBlockStartOffset,
			  TInt64 aStartBlockAddress,
			  TUint aReadUnitShift,
			  TUint aCodeLengthInFile,
			  TUint aEntriesSize,
			  ...);
	inline const SBlockMapInfoBase& Info() const { return iInfo; }
	inline TInt ReadUnitShift() const { return iReadUnitShift; }
	inline TInt CodeLengthInFile() const { return iCodeLengthInFile; }
	inline TInt EntriesSize() const { return iEntriesSize; }
private:
	SBlockMapInfoBase iInfo;
	TBlockMapEntryBase* iEntries;
	TUint iReadUnitShift;
	TUint iCodeLengthInFile;
	TUint iEntriesSize;
	};

CBlockMap::CBlockMap(TUint aBlockGranularity,
					 TUint aBlockStartOffset,
					 TInt64 aStartBlockAddress,
					 TUint aReadUnitShift,
					 TUint aCodeLengthInFile,
					 TUint aEntriesSize,
					 ...)
	{
	iInfo.iBlockGranularity = aBlockGranularity;
	iInfo.iBlockStartOffset = aBlockStartOffset;
	iInfo.iStartBlockAddress = aStartBlockAddress;
	// don't care about iInfo.iLocalDriveNumber for test purposes
	iReadUnitShift = aReadUnitShift;
	iCodeLengthInFile = aCodeLengthInFile;
	iEntriesSize = aEntriesSize;
	iEntries = (TBlockMapEntryBase*)User::Alloc(iEntriesSize);

	VA_LIST list;
	VA_START(list, aEntriesSize);
	Set(iEntriesSize / sizeof(TBlockMapEntryBase), list);
	}

/// A list of extents, for comparison with those generated by the kernel block map processing code
class CExtentList : public CList<TBlockMap::SExtent>
	{
public:
	typedef TBlockMap::SExtent SExtent;
	CExtentList(TInt aCount, ...);
	void Dump() const;
	};

CExtentList::CExtentList(TInt aCount, ...)
	{
	VA_LIST list;
	VA_START(list, aCount);
	Set(aCount, list);
	}

void CExtentList::Dump() const
	{
	RDebug::Printf("CExtentList:\n");
	const CExtentList& self = *this;
	for (TInt i = 0 ; i < Count() ; ++i)
		RDebug::Printf("  %d: %08x -> %08x: %08x\n", i, self[i].iDataOffset, self[i+1].iDataOffset, self[i].iBlockNumber);
	}

TBool operator==(const TBlockMap::SExtent& a, const TBlockMap::SExtent& b)
	{
	return a.iDataOffset == b.iDataOffset && a.iBlockNumber == b.iBlockNumber;
	}

TBool operator!=(const TBlockMap::SExtent& a, const TBlockMap::SExtent& b)
	{
	return !(a == b);
	}

TBool CompareExtentsEqual(const TBlockMap& aBlockMap, const CExtentList& aExtentList)
	{
	if (aBlockMap.Count() != aExtentList.Count())
		return EFalse;
	for (TInt i = 0 ; i < aBlockMap.Count() ; ++i)
		{
		if (aBlockMap.Extent(i) != aExtentList[i])
			return EFalse;
		}
	return ETrue;
	}

TInt MakeKernBlockMap(TBlockMap& aKbm, const CBlockMap& aUbm)
	{
	TBlockMapEntryBase* buffer = (TBlockMapEntryBase*)User::Alloc(aUbm.EntriesSize());
	test_notNull(buffer);
	Mem::Copy(buffer, aUbm.Entries(), aUbm.EntriesSize());
	return aKbm.Initialise(aUbm.Info(),
						   buffer,
						   aUbm.EntriesSize(),
						   aUbm.ReadUnitShift(),
						   aUbm.CodeLengthInFile());
}

void MakeKernBlockMapAndTestExtents(const CBlockMap& aUbm, const CExtentList& aExpectedExtentList)
	{
	TBlockMap kbm;
	test_noError(MakeKernBlockMap(kbm, aUbm));
	TBool equal = CompareExtentsEqual(kbm, aExpectedExtentList);
	if (!equal)
		{
		aExpectedExtentList.Dump();
#ifdef _DEBUG
		kbm.Dump();
#endif
		}
	test(equal);
	}

// Tests

void TestInitialiseErrors()
	{
	test.Next(_L("Test Initialise error checking"));
	TBlockMap kbm;

	// Block size must be a power of two
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(513, 0, 0, 9, 1, 8, 1, 0)));

	// Block size must be greater than or equal to the read unit size
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 10, 1, 8, 1, 0)));

	// Block start offset must be less than or equal to block size
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 513, 0, 9, 1, 8, 1, 0)));

	// Block zero address must be a multiple of the block size
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 1, 9, 1, 8, 1, 0)));

	// Code length in file must be greater than zero
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 0, 8, 1, 0)));

	// Size of entries array must be multiple of the size of one entry
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 1, 9, 1, 0)));

	// Size of entries must be non-zero
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 1, 0)));
	
	// Size of block map must be greater or equal to size of data in file
	test_equal(KErrArgument, MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 513, 8, 1, 0)));
	}

	// blockGranularity, startOffset, blockZeroAddress, readUnitShift, codeLengthInFile, entriesSize, (numberOfBlocks, startBlock)+

void TestExtentList()
	{
	test.Next(_L("Test processing of user-side block map into extent list"));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |=      |       |       |       |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 0, 0, 9, 1, 8, 1, 0),
								   CExtentList(1, 0, 0));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |=      |       |       |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 0, 512, 9, 1, 8, 1, 0),
								   CExtentList(1, 0, 1));
	
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       | =     |       |       |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 1, 8, 1, 0),
								   CExtentList(1, -23, 1));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | =     |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 1, 8, 1, 2),
								   CExtentList(1, -23, 3));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | ======|       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 489, 8, 1, 2),
								   CExtentList(1, -23, 3));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | ========      |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 600, 8, 2, 2),
								   CExtentList(1, -23, 3));
	
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | ==============|       |==     |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 1100, 16, 2, 2, 1, 5),
								   CExtentList(2, -23, 3, 1001, 6));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | ==============|       |=======|       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 1513, 16, 2, 2, 1, 5),
								   CExtentList(2, -23, 3, 1001, 6));
	
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |       |       |       | ==============|       |=======|=      |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 9, 1540, 16, 2, 2, 2, 5),
								   CExtentList(2, -23, 3, 1001, 6));
	}

void TestExtentListScaled()
	{
	test.Next(_L("Test processing of user-side block map into extent list, block size > read unit size"));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |=  :   |   :   |   :   |   :   |   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 0, 0, 8, 1, 8, 1, 0),
								   CExtentList(1, 0, 0));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |=  :   |   :   |   :   |   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 0, 512, 8, 1, 8, 1, 0),
								   CExtentList(1, 0, 2));
	
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   | = :   |   :   |   :   |   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 23, 512, 8, 1, 8, 1, 0),
								   CExtentList(1, -23, 2));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   : = |   :   |   :   |   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 1, 8, 1, 0),
								   CExtentList(1, -24, 3));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : = |   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 1, 8, 1, 2),
								   CExtentList(1, -24, 7));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==|   :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 232, 8, 1, 2),
								   CExtentList(1, -24, 7));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ====  :   |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 333, 8, 2, 2),
								   CExtentList(1, -24, 7));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ========  |   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 666, 8, 2, 2),
								   CExtentList(1, -24, 7));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==========|   :   |   :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 744, 8, 2, 2),
								   CExtentList(1, -24, 7));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==========|   :   |== :   |   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 888, 16, 2, 2, 1, 5),
								   CExtentList(2, -24, 7, 744, 12));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==========|   :   |=======|   :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 1256, 16, 2, 2, 1, 5),
								   CExtentList(2, -24, 7, 744, 12));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==========|   :   |=========  :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	MakeKernBlockMapAndTestExtents(CBlockMap(512, 280, 512, 8, 1350, 16, 2, 2, 2, 5),
								   CExtentList(2, -24, 7, 744, 12));
	}

/// Holds the expected arguments for one call to the read function
struct SReadEntry
	{
	TLinAddr iBuffer;
	TInt iBlockNumber;
	TInt iBlockCount;
	};

/// Holds a list of expected arguments for all calls to the read function
class CReadInfo : public CList<SReadEntry>
	{
public:
	CReadInfo(TInt aReturnVal, TInt aCount, ...);
	const SReadEntry& Next();
	void Done() const;
	TInt ReturnVal() const { return iReturnVal; }
private:
	TInt iPos;
	TInt iReturnVal;
	};

CReadInfo::CReadInfo(TInt aReturnVal, TInt aCount, ...)
	: iPos(0), iReturnVal(aReturnVal)
	{
	VA_LIST list;
	VA_START(list, aCount);
	Set(aCount, list);
	}

const SReadEntry& CReadInfo::Next()
	{
	const CList<SReadEntry>& self = *this;
	return self[iPos++];
	}

void CReadInfo::Done() const
	{
	test_equal(Count(), iPos);
	}

TInt ReadFunc(TAny* aArg, TAny*, TLinAddr aBuffer, TInt aBlockNumber, TInt aBlockCount)
	{
	CReadInfo& info = *(CReadInfo*)aArg;
	const SReadEntry& expected = info.Next();
	test_equal(expected.iBuffer, aBuffer);
	test_equal(expected.iBlockNumber, aBlockNumber);
	test_equal(expected.iBlockCount, aBlockCount);
	return KErrNone;
	}

void TestRead(const TBlockMap& aBlockMap,
			  TLinAddr aBuffer,
			  TInt aPos,
			  TInt aLength,
			  TInt aReadUnitShift,
			  const CReadInfo& aExpected)
	{
	test_equal(aExpected.ReturnVal(),
			   aBlockMap.Read(aBuffer, aPos, aLength, aReadUnitShift, ReadFunc, (TAny*)&aExpected, (TAny*)NULL));
	aExpected.Done();
	}

void TestReadErrors()
	{
	test.Next(_L("Test Read error checking"));

	TBlockMap kbm, kbm2;
	
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |=      |       |       |       |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	test_noError(MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 1, 8, 1, 0)));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   :   |   :   |   :   |   : ==========|   :   |=========  :   |   :   |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------	
	test_noError(MakeKernBlockMap(kbm2, CBlockMap(512, 280, 512, 8, 1350, 16, 2, 2, 2, 5)));

	// Test read start position is outside block map
	TestRead(kbm, 0, 1, 1, 9, CReadInfo(KErrArgument, 0));
	TestRead(kbm2, 0, 1350, 1, 8, CReadInfo(KErrArgument, 0));

	// Test read start position is negative
	TestRead(kbm, 0, -1, 1, 9, CReadInfo(KErrArgument, 0));
	TestRead(kbm2, 0, -1, 1, 8, CReadInfo(KErrArgument, 0));

	// Test read length exceeds block map length 
	TestRead(kbm, 0, 0, 2, 9, CReadInfo(KErrArgument, 1, 0, 0, 1));
	TestRead(kbm2, 0, 1349, 2, 8, CReadInfo(KErrArgument, 1, 0, 14, 1));
	}

void TestReads()
	{
	test.Next(_L("Test Read"));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |=======================|       |       |       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	
	TBlockMap kbm2;
	test_noError(MakeKernBlockMap(kbm2, CBlockMap(512, 0, 0, 9, 1536, 8, 3, 0)));

	// Test correct number of blocks read
	TestRead(kbm2, 0, 0, 512, 9, CReadInfo(0, 1, 0, 0, 1));
	TestRead(kbm2, 0, 0, 513, 9, CReadInfo(0, 1, 0, 0, 2));
	TestRead(kbm2, 0, 0, 1024, 9, CReadInfo(0, 1, 0, 0, 2));
	TestRead(kbm2, 0, 0, 1025, 9, CReadInfo(0, 1, 0, 0, 3));
	TestRead(kbm2, 0, 0, 1536, 9, CReadInfo(0, 1, 0, 0, 3));

	// Test start offset not aligned to read unit
	TestRead(kbm2, 0, 1, 511, 9, CReadInfo(1, 1, 0, 0, 1));
	TestRead(kbm2, 0, 256, 256, 9, CReadInfo(256, 1, 0, 0, 1));
	TestRead(kbm2, 0, 511, 1, 9, CReadInfo(511, 1, 0, 0, 1));
	TestRead(kbm2, 0, 513, 511, 9, CReadInfo(1, 1, 0, 1, 1));
	TestRead(kbm2, 0, 1023, 1, 9, CReadInfo(511, 1, 0, 1, 1));

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |=======|       |=======|       |=======|       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	
	TBlockMap kbm;
	test_noError(MakeKernBlockMap(kbm, CBlockMap(512, 0, 0, 9, 1536, 24, 1, 0, 1, 3, 1, 5)));

	// Test correct block selected for read
	TestRead(kbm, 0, 0, 1, 9, CReadInfo(0, 1, 0, 0, 1));
	TestRead(kbm, 0, 256, 1, 9, CReadInfo(256, 1, 0, 0, 1));
	TestRead(kbm, 0, 511, 1, 9, CReadInfo(511, 1, 0, 0, 1));
	TestRead(kbm, 0, 512, 1, 9, CReadInfo(0, 1, 0, 3, 1));
	TestRead(kbm, 0, 768, 1, 9, CReadInfo(256, 1, 0, 3, 1));
	TestRead(kbm, 0, 1023, 1, 9, CReadInfo(511, 1, 0, 3, 1));
	TestRead(kbm, 0, 1535, 1, 9, CReadInfo(511, 1, 0, 5, 1));

	// Test reading multiple blocks
	TestRead(kbm, 0, 0, 513, 9, CReadInfo(0, 2, 0, 0, 1, 512, 3, 1));
	TestRead(kbm, 0, 0, 1024, 9, CReadInfo(0, 2, 0, 0, 1, 512, 3, 1));
	TestRead(kbm, 0, 0, 1025, 9, CReadInfo(0, 3, 0, 0, 1, 512, 3, 1, 1024, 5, 1));
	TestRead(kbm, 0, 0, 1536, 9, CReadInfo(0, 3, 0, 0, 1, 512, 3, 1, 1024, 5, 1));


	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	//  |   ====|       |=======|       |=======|       |       |       |       |
	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
	
	TBlockMap kbm3;
	test_noError(MakeKernBlockMap(kbm3, CBlockMap(512, 256, 0, 9, 1280, 24, 1, 0, 1, 3, 1, 5)));

	// Test correct block selected for read
	TestRead(kbm3, 0, 0, 1, 9, CReadInfo(256, 1, 0, 0, 1));
	TestRead(kbm3, 0, 255, 1, 9, CReadInfo(511, 1, 0, 0, 1));
	TestRead(kbm3, 0, 256, 1, 9, CReadInfo(0, 1, 0, 3, 1));
	TestRead(kbm3, 0, 767, 1, 9, CReadInfo(511, 1, 0, 3, 1));
	TestRead(kbm3, 0, 768, 1, 9, CReadInfo(0, 1, 0, 5, 1));

	// Test reading multiple blocks
	TestRead(kbm3, 0, 0, 256, 9, CReadInfo(256, 1, 0, 0, 1));
	TestRead(kbm3, 0, 0, 257, 9, CReadInfo(256, 2, 0, 0, 1, 512, 3, 1));
	TestRead(kbm3, 0, 0, 768, 9, CReadInfo(256, 2, 0, 0, 1, 512, 3, 1));
	TestRead(kbm3, 0, 0, 769, 9, CReadInfo(256, 3, 0, 0, 1, 512, 3, 1, 1024, 5, 1));
	TestRead(kbm3, 0, 0, 1280, 9, CReadInfo(256, 3, 0, 0, 1, 512, 3, 1, 1024, 5, 1));
	}

TInt E32Main()
	{
	test.Title();
	test.Start(_L("Unit tests the TKernBlockMap class"));

	TestInitialiseErrors();
	TestExtentList();
	TestExtentListScaled();
	TestReadErrors();
	TestReads();
 
	test.End();

	return KErrNone;
	}