aLength -= RHeap::EAllocCellSize;

	aLength -= RHeap::EAllocCellSize;

	if (aLength==0)

	DECL_GET(TInt,AccessCount)

	DECL_GET(TInt,HandleCount)

	DECL_GET(TInt*,Handles)

	DECL_GET(TUint32,Flags)

	DECL_GET(TInt,CellCount)

	DECL_GET(TInt,TotalAllocSize)

	DECL_GET(TInt,MinLength)

	DECL_GET(TInt,Offset)

	DECL_GET(TInt,GrowBy)

	DECL_GET(TInt,ChunkHandle)

	DECL_GET2(const RFastLock&,Lock,LockRef)

	DECL_GET(TUint8*,Top)

	DECL_GET(TInt,Align)

	DECL_GET(TInt,MinCell)

	DECL_GET(TInt,PageSize)

	DECL_GET2(const SCell&,Free,FreeRef)

public:

	TInt FreeCellLen(const TAny* aPtr) const;

	static RTestHeap* FixedHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);

	void TakeChunkOwnership(RChunk aChunk);

	TInt LastFreeCellLen(void) const;

	TInt CalcComp(TInt aCompSize);

	void ForceCompress(TInt aFreed);

	SCell* pC = GetAddress(aCell);

	TInt len = pC->len;

	TUint8* pEnd = (TUint8*)pC + len;

	TEST_ALIGN(aCell, iAlign);

	TEST_ALIGN(len, iAlign);

	test(len >= iMinCell);

	test((TUint8*)pC>=iBase && pEnd<=iTop);

		test((len-RHeap::EAllocCellSize)>=aSize);

	test((new_len-RHeap::EAllocCellSize)>=aSize);

		((STestCell*)p)->Verify(aPtr, old_len, Min(old_len, new_len));

	if (new_len != old_len)

		((STestCell*)p)->Set(new_len);

			test(aCell == info.iNextCell);

			TInt len = ((SCell*)aCell)->len;

			test(len == aLen);

			info.iNextCell += len;

			info.iTotalAllocSize += (aLen-EAllocCellSize);

			STestCell* pT = (STestCell*)((TUint8*)aCell + EAllocCellSize);

			test(aCell == info.iNextCell);

			TInt len = ((SCell*)aCell)->len;

			test(len == aLen);

			info.iNextCell += len;

	info.iNextCell = iBase;

	test(info.iNextCell == iTop);

	test(info.iTotalAlloc == iCellCount);

	}

TInt RTestHeap::FreeCellLen(const TAny* aPtr) const

	{

	SCell* p = iFree.next;

	SCell* q = (SCell*)((TUint8*)aPtr - EAllocCellSize);

	for (; p && p!=q; p = p->next) {}

	if (p == q)

		return p->len - EAllocCellSize;

	return -1;

	}

TInt RTestHeap::LastFreeCellLen(void) const

	{

	SCell* p = iFree.next;

	if (p==NULL)

		return -1;	

	for (; p->next; p=p->next){}

	return p->len;

	}

/** Checks whether a call to Compress() will actually perform a reduction 

	of the heap.

	Relies on the free last cell on the heap being cell that has just been freed

	plus any extra.

	Intended for use by t_heap2.cpp - DoTest4().  

	@param aFreedSize The size in bytes of the cell that was freed

*/

TInt RTestHeap::CalcComp(TInt aFreedSize)

	{	

	TInt largestCell=0;

	largestCell = LastFreeCellLen();

	// if the largest cell is too small or it would have been compressed by the

	// free operation then return 0.

	if (largestCell < iPageSize || aFreedSize >= KHeapShrinkHysRatio*(iGrowBy>>8))

		{

		return 0;			

		}

		else

		{

		return _ALIGN_DOWN(aFreedSize,iPageSize);

		}	

/** compress the heap if the KHeapShrinkRatio is too large for what we are

	expecting in DoTest4().

*/

void RTestHeap::ForceCompress(TInt aFreed)

	{	

	if (aFreed < KHeapShrinkHysRatio*(iGrowBy>>8))

		{

		Compress();

		}

	}

RTestHeap* RTestHeap::FixedHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)

	{

	RChunk c;

	TInt bottom = 0x40000;

	TInt top = bottom + aMaxLength;

	TInt r = c.CreateDisconnectedLocal(bottom, top, top + bottom, EOwnerThread);

	if (r!=KErrNone)

		return NULL;

	TUint8* base = c.Base() + bottom;

	RTestHeap* h = (RTestHeap*)UserHeap::FixedHeap(base, aMaxLength, aAlign, aSingleThread);

	if (!aAlign)

		aAlign = RHeap::ECellAlignment;

	test((TUint8*)h == base);

	test(h->AccessCount() == 1);

	test(h->HandleCount() == (aSingleThread ? 0 : 1));

	test(h->Handles() == (aSingleThread ? NULL : (TInt*)&h->LockRef()));

	test(h->Flags() == TUint32(RAllocator::EFixedSize | (aSingleThread ? RAllocator::ESingleThreaded : 0)));

	test(h->CellCount() == 0);

	test(h->TotalAllocSize() == 0);

	test(h->MaxLength() == aMaxLength);

	test(h->MinLength() == h->Top() - (TUint8*)h);

	test(h->Offset() == 0);

	test(h->GrowBy() == 0);

	test(h->ChunkHandle() == 0);

	test(h->Align() == aAlign);

	TInt min_cell = _ALIGN_UP((KHeapMinCellSize + Max((TInt)RHeap::EAllocCellSize, (TInt)RHeap::EFreeCellSize)), aAlign);

	TInt hdr_len = _ALIGN_UP(sizeof(RHeap) + RHeap::EAllocCellSize, aAlign) - RHeap::EAllocCellSize;

	TInt user_len = _ALIGN_DOWN(aMaxLength - hdr_len, aAlign);

	test(h->Base() == base + hdr_len);

	test(h->MinCell() == min_cell);

	test(h->Top() - h->Base() == user_len);

	test(h->FreeRef().next == (RHeap::SCell*)h->Base());

	h->TakeChunkOwnership(c);

	return h;

	}

void RTestHeap::TakeChunkOwnership(RChunk aChunk)

	{

	iChunkHandle = aChunk.Handle();

	++iHandleCount;

	iHandles = &iChunkHandle;

	}

#define	ACCESS_COUNT(h)		(((RTestHeap*)h)->AccessCount())

#define	HANDLE_COUNT(h)		(((RTestHeap*)h)->HandleCount())

#define	HANDLES(h)			(((RTestHeap*)h)->Handles())

#define	FLAGS(h)			(((RTestHeap*)h)->Flags())

#define	CELL_COUNT(h)		(((RTestHeap*)h)->CellCount())

#define	TOTAL_ALLOC_SIZE(h)	(((RTestHeap*)h)->TotalAllocSize())

#define	MIN_LENGTH(h)		(((RTestHeap*)h)->MinLength())

#define	OFFSET(h)			(((RTestHeap*)h)->Offset())

#define	GROW_BY(h)			(((RTestHeap*)h)->GrowBy())

#define	CHUNK_HANDLE(h)		(((RTestHeap*)h)->ChunkHandle())

#define	LOCK_REF(h)			(((RTestHeap*)h)->LockRef())

#define	TOP(h)				(((RTestHeap*)h)->Top())

#define	ALIGN(h)			(((RTestHeap*)h)->Align())

#define	MIN_CELL(h)			(((RTestHeap*)h)->MinCell())

#define	PAGE_SIZE(h)		(((RTestHeap*)h)->PageSize())

#define	FREE_REF(h)			(((RTestHeap*)h)->FreeRef())

void DoTest1(RHeap* aH)

	{

	RTestHeap* h = (RTestHeap*)aH;

	test.Printf(_L("Test Alloc: min=%x max=%x align=%d growby=%d\n"),

						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());

	TInt l;

	TAny* p = NULL;

	TUint8* next = h->Base();

	TUint8* top = h->Top();

	TUint8* limit = (TUint8*)h + h->MaxLength();

	TBool fixed = h->Flags() & RAllocator::EFixedSize;

	for (l=1; l<=1024; ++l)

		{

		TInt remain1 = top - next;

		TInt xl1 = _ALIGN_UP(Max((l+RHeap::EAllocCellSize), h->MinCell()), h->Align());

		p = h->TestAlloc(l);

		if ( (fixed && remain1 < xl1) || (next + xl1 > limit) )

			{

			test(p == NULL);

			test(top == h->Top());

			test.Printf(_L("Alloc failed at l=%d next=%08x\n"), l, next);

			break;

			}

		test(p == next + RHeap::EAllocCellSize);

		if (xl1 > remain1)

			{

			// no room for this cell

			TInt g = h->GrowBy();

			while (xl1 > remain1)

				{

				top += g;

				remain1 += g;

				}

			}

		test(top == h->Top());

		if (xl1 + h->MinCell() > remain1)

			{

			// this cell fits but remainder is too small or nonexistent

			xl1 = top - next;

			next = top;

			test(h->FreeRef().next == NULL);

			}

		else

			{

			// this cell fits and remainder can be reused

			next += xl1;

			}

		test(aH->AllocLen(p) == xl1 - RHeap::EAllocCellSize);

		}

	h->FullCheck();

	}

void DoTest2(RHeap* aH)

	{

	RTestHeap* h = (RTestHeap*)aH;

	test.Printf(_L("Test Free: min=%x max=%x align=%d growby=%d\n"),

						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());

	TInt al;

	TInt min = h->MinCell();

	TBool pad = EFalse;

	for (al=1; al<256; (void)((pad=!pad)!=0 || (al+=al+1)) )

		{

		TAny* p[32];

		TInt last_len = 0;

		TAny* last = NULL;

		TInt i;

		test.Printf(_L("al=%d pad=%d\n"), al, pad);

		TUint8* top=0;

		TAny* spare=0;

		TBool heapReduced = EFalse;

		for (i=0; i<32; ++i)

			{

			// Check whether the cell created for the allocation of al would end up

			// including extra bytes from the last free cell that aren't enough

			// to create a new free cell.

			top = h->Top();

			TInt freeLen=h->LastFreeCellLen();

			TInt actualAllocBytes = Max(_ALIGN_UP(al + RHeap::EAllocCellSize, h->Align()), min);

			TInt remainingBytes = freeLen - actualAllocBytes;

			if (remainingBytes < min)

				{

				// Force the heap to grow so that once this allocation is freed

				// the free cell left will be large enough to include the al allocation

				// and to create a new free cell if necessary.

				actualAllocBytes = _ALIGN_UP(actualAllocBytes + min, h->Align());

				TAny* q = h->TestAlloc(actualAllocBytes);

				// Check heap has grown

				test(top < h->Top());

				top = h->Top();

				test(q!=NULL);

				// Have grown the heap so allocate a cell as a place holder to stop

				// the heap being shrunk and the actual cell we want to allocate from being the

				// wrong size

				spare=h->TestAlloc(8);

				h->TestFree(q);

				// Ensure heap wasn't shrunk after free

				test(top == h->Top());

				}

			top = h->Top();

			// Allocate the new 

			p[i] = h->TestAlloc(al);

			test(p[i]!=NULL);

			if (remainingBytes < min)

				{// now safe to free any padding as p[i] now allocated and its size can't change

				h->TestFree(spare);

				}

			TInt tmp1=h->AllocLen(p[i]);

			TInt tmp2=Max(_ALIGN_UP(al+RHeap::EAllocCellSize,h->Align()), min)-RHeap::EAllocCellSize;

			test(tmp1 == tmp2);

			}

		last = (TUint8*)p[31] + _ALIGN_UP(Max((al + RHeap::EAllocCellSize), min), h->Align());

		last_len = h->FreeCellLen(last);

		test(last_len > 0);

		if (pad)

			{

			test(h->TestAlloc(last_len) == last);

			test(h->FreeRef().next == NULL);

			}

		else

			last = NULL;

		top = h->Top();

		for (i=0,heapReduced=EFalse; i<32; ++i)

			{