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

 	}