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

	//  +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------

	//  |=======|       |=======|       |=======|       |       |       |       |