// Copyright (c) 2002-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\heap\t_heap2.cpp
// Overview:
// Tests RHeap class, including a stress test and a "grow in place"
// ReAlloc test.
// API Information:
// RHeap
// Details:
// - Test allocation on fixed length heaps in local, disconnected chunks for
// different heap sizes and alignments.  Assumes knowledge of heap
// implementation.
// - Test allocation, free, reallocation and compression on chunk heaps with
// different maximum and minimum lengths and alignments.  Assumes knowledge
// of heap implementation.      
// - Stress test heap implementation with a single thread that allocates, frees
// and reallocates cells, and checks the heap.
// - Stress test heap implementation with two threads that run concurrently.
// - Create a chunk heap, test growing in place by allocating a cell and 
// then reallocating additional space until failure, verify that the cell 
// did not move and the size was increased.
// - The heap is checked to verify that no cells remain allocated after the 
// tests are complete.
// Platforms/Drives/Compatibility:
// All
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

#include <e32test.h>
#include <e32hal.h>
#include <e32def.h>
#include <e32def_private.h>

// Needed for KHeapShrinkHysRatio which is now ROM 'patchdata'
#include "TestRHeapShrink.h"

#define DECL_GET(T,x)		inline T x() const {return i##x;}
#define DECL_GET2(T,x,y)	inline T y() const {return i##x;}


#ifdef __EABI__
       IMPORT_D extern const TInt KHeapMinCellSize;
#else
       const TInt KHeapMinCellSize = 0;
#endif

RTest test(_L("T_HEAP2"));

#define	TEST_ALIGN(p,a)		test((TLinAddr(p)&((a)-1))==0)

struct STestCell
	{
	enum {EMagic = 0xb8aa3b29};

	TUint32 iLength;
	TUint32 iData[1];

	void Set(TInt aLength);
	void Verify(TInt aLength);
	void Verify(const TAny* aInitPtr, TInt aInitLength, TInt aLength);
	};

void STestCell::Set(TInt aLength)
	{
	TInt i;
	TUint32 x = (TUint32)this ^ (TUint32)aLength ^ (TUint32)EMagic;
	aLength -= RHeap::EAllocCellSize;
	if (aLength==0)
		return;
	iLength = x;
	aLength /= sizeof(TUint32);
	for (i=0; i<aLength-1; ++i)
		{
		x *= 69069;
		x += 41;
		iData[i] = x;
		}
	}

void STestCell::Verify(TInt aLength)
	{
	Verify(this, aLength, aLength);
	}

void STestCell::Verify(const TAny* aInitPtr, TInt aInitLength, TInt aLength)
	{
	TInt i;
	TUint32 x = (TUint32)aInitPtr ^ (TUint32)aInitLength ^ (TUint32)EMagic;
	aLength -= RHeap::EAllocCellSize;
	if (aLength==0)
		return;
	test(iLength == x);
	aLength /= sizeof(TUint32);
	for (i=0; i<aLength-1; ++i)
		{
		x *= 69069;
		x += 41;
		test(iData[i] == x);
		}
	}

class RTestHeap : public RHeap
	{
public:
	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 CheckAllocatedCell(const TAny* aCell) const;
	void FullCheckAllocatedCell(const TAny* aCell) const;
	TAny* TestAlloc(TInt aSize);
	void TestFree(TAny* aPtr);
	TAny* TestReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0);
	void FullCheck();
	static void WalkFullCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);
	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);
	};

TInt RTestHeap::CheckAllocatedCell(const TAny* aCell) const
	{
	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);
	return len;
	}

void RTestHeap::FullCheckAllocatedCell(const TAny* aCell) const
	{
	((STestCell*)aCell)->Verify(CheckAllocatedCell(aCell));
	}

TAny* RTestHeap::TestAlloc(TInt aSize)
	{
	TAny* p = Alloc(aSize);
	if (p)
		{
		TInt len = CheckAllocatedCell(p);
		test((len-RHeap::EAllocCellSize)>=aSize);
		((STestCell*)p)->Set(len);
		}
	return p;
	}

void RTestHeap::TestFree(TAny* aPtr)
	{
	if (aPtr)
		FullCheckAllocatedCell(aPtr);
	Free(aPtr);
	}

TAny* RTestHeap::TestReAlloc(TAny* aPtr, TInt aSize, TInt aMode)
	{
	TInt old_len = aPtr ? CheckAllocatedCell(aPtr) : 0;
	if (aPtr)
		((STestCell*)aPtr)->Verify(old_len);
	TAny* p = ReAlloc(aPtr, aSize, aMode);
	if (!p)
		{
		((STestCell*)aPtr)->Verify(old_len);
		return p;
		}
	TInt new_len = CheckAllocatedCell(p);
	test((new_len-RHeap::EAllocCellSize)>=aSize);
	if (p == aPtr)
		{
		((STestCell*)p)->Verify(p, old_len, Min(old_len, new_len));
		if (new_len != old_len)
			((STestCell*)p)->Set(new_len);
		return p;
		}
	test(!(aMode & ENeverMove));
	test((new_len > old_len) || (aMode & EAllowMoveOnShrink));
	if (old_len)
		((STestCell*)p)->Verify(aPtr, old_len, Min(old_len, new_len));
	if (new_len != old_len)
		((STestCell*)p)->Set(new_len);
	return p;
	}

struct SHeapCellInfo
	{
	RTestHeap* iHeap;
	TInt iTotalAlloc;
	TInt iTotalAllocSize;
	TInt iTotalFree;
	TUint8* iNextCell;
	};

void RTestHeap::WalkFullCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen)
	{
	(void)aCell;
	::SHeapCellInfo& info = *(::SHeapCellInfo*)aPtr;
	switch(aType)
		{
		case EGoodAllocatedCell:
			{
			test(aCell == info.iNextCell);
			TInt len = ((SCell*)aCell)->len;
			test(len == aLen);
			info.iNextCell += len;
			++info.iTotalAlloc;
			info.iTotalAllocSize += (aLen-EAllocCellSize);
			STestCell* pT = (STestCell*)((TUint8*)aCell + EAllocCellSize);
			pT->Verify(len);
			break;
			}
		case EGoodFreeCell:
			{
			test(aCell == info.iNextCell);
			TInt len = ((SCell*)aCell)->len;
			test(len == aLen);
			info.iNextCell += len;
			++info.iTotalFree;
			break;
			}
		default:
			test.Printf(_L("TYPE=%d ??\n"),aType);
			test(0);
			break;
		}
	}

void RTestHeap::FullCheck()
	{
	::SHeapCellInfo info;
	Mem::FillZ(&info, sizeof(info));
	info.iHeap = this;
	info.iNextCell = iBase;
	DebugFunction(EWalk, (TAny*)&WalkFullCheckCell, &info);
	test(info.iNextCell == iTop);
	test(info.iTotalAlloc == iCellCount);
	test(info.iTotalAllocSize == iTotalAllocSize);
	}

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)
			{
			h->TestFree(p[i]);
			TInt fl = h->FreeCellLen(p[i]);
			TInt xfl = _ALIGN_UP(Max((al + RHeap::EAllocCellSize), h->MinCell()), h->Align()) - RHeap::EAllocCellSize;
			if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
				{
				top = h->Top();
				heapReduced = ETrue;
				}

			if (i < 31 || pad)
				test(fl == xfl);
			else
				{
				if (!heapReduced)
					test(fl == xfl + RHeap::EAllocCellSize + last_len);
				else
					{
					heapReduced = EFalse;
					}
				}
			test(h->TestAlloc(al)==p[i]);
			}
		for (i=0,heapReduced=EFalse; i<31; ++i)
			{
			TInt j = i+1;
			TUint8* q;
			// Free to adjacent cells and check that the free cell left is the combined
			// size of the 2 adjacent cells just freed
			h->TestFree(p[i]);
			h->TestFree(p[j]);
			TInt fl = h->FreeCellLen(p[i]);
			if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
				{
				top = h->Top();
				heapReduced = ETrue;
				}
			TInt xfl = 2 * _ALIGN_UP(Max((al + RHeap::EAllocCellSize), h->MinCell()), h->Align()) - RHeap::EAllocCellSize;
			if (j < 31 || pad)
				test(fl == xfl);
			else
				{
				if (!heapReduced)
					test(fl == xfl + RHeap::EAllocCellSize + last_len);
				else
					{
					heapReduced = EFalse;
					}
				}
			test(h->FreeCellLen(p[j]) < 0);
			test(h->TestAlloc(fl)==p[i]);
			test(h->Top() == top);
			h->TestFree(p[i]);
			test(h->FreeCellLen(p[i]) == fl);
			// test when you alloc a cell that is larger than cells just freed
			// that its position is not the same as the freed cells
			// will hold for all cells except top/last one
			if (j < 31 && !pad && fl < last_len)
				{
				q = (TUint8*)h->TestAlloc(fl+1);
				if (h->Top() > top)
					top = h->Top();
				test(h->Top() == top);
				test(q > p[i]);
				h->TestFree(q);
				if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
					{
					top = h->Top();
					heapReduced = ETrue;
					}
				}
			// check cell that is just smaller than space but not small enough 
			// for a new free cell to be created, is the size of whole free cell
			test(h->TestAlloc(fl-min+1)==p[i]);
			test(h->Top() == top);
			test(h->AllocLen(p[i])==fl);
			h->TestFree(p[i]);
			// Check cell that is small enough for new free cell and alloc'd cell to be
			// created at p[i] cell is created at p[i]
			test(h->TestAlloc(fl-min)==p[i]);
			test(h->Top() == top);
			// check free cell is at expected position
			q = (TUint8*)p[i] + fl - min + RHeap::EAllocCellSize;
			test(h->FreeCellLen(q) == min - RHeap::EAllocCellSize);
			// alloc 0 length cell at q, will work as new cell of min length will be created
			test(h->TestAlloc(0) == q);
			test(h->Top() == top);
			h->TestFree(p[i]);
			test(h->FreeCellLen(p[i]) == fl - min);
			h->TestFree(q);
			// again check free cells are combined
			test(h->FreeCellLen(q) < 0);
			test(h->FreeCellLen(p[i]) == fl);
			// check reallocating the cells places them back to same positions
			test(h->TestAlloc(al)==p[i]);
			test(h->Top() == top);
			test(h->TestAlloc(al)==p[j]);
			test(h->Top() == top);
			if (pad)
				test(h->FreeRef().next == NULL);
			}
		for (i=0,heapReduced=EFalse; i<30; ++i)
			{
			TInt j = i+1;
			TInt k = i+2;
			TUint8* q;
			// Free 3 adjacent cells and check free cell created is combined size
			h->TestFree(p[i]);
			h->TestFree(p[k]);
			h->TestFree(p[j]);
			h->FullCheck();
			if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
				{
				top = h->Top();
				heapReduced = ETrue;
				}
			TInt fl = h->FreeCellLen(p[i]);
			TInt xfl = 3 * _ALIGN_UP(Max((al + RHeap::EAllocCellSize), h->MinCell()), h->Align()) - RHeap::EAllocCellSize;
			if (k < 31 || pad)
				test(fl == xfl);
			else
				{
				if (!heapReduced)
					test(fl == xfl + RHeap::EAllocCellSize + last_len);
				else
					{
					heapReduced = EFalse;
					}
				}
			test(h->FreeCellLen(p[j]) < 0);
			test(h->FreeCellLen(p[k]) < 0);
			//ensure created free cell is allocated to new cell of free cell size
			test(h->TestAlloc(fl)==p[i]);
			test(h->Top() == top);
			h->TestFree(p[i]);
			test(h->FreeCellLen(p[i]) == fl);
			if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
				top = h->Top();
			if (k < 31 && !pad && fl < last_len)
				{
				// Test new cell one larger than free cell size is allocated somewhere else
				q = (TUint8*)h->TestAlloc(fl+1);
				if (h->Top() > top)
					top = h->Top();
				test(h->Top() == top); 
				test(q > p[i]);
				h->TestFree(q);
				if (h->Top() < top) // heap was reduced due to small KHeapShrinkHysRatio and big KHeapMinCellSize
					{
					top = h->Top();
					heapReduced = ETrue;
					}
				}
			// check allocating cell just smaller than free cell size but
			// too large for neew free cell to be created, is size of whole free cell
			test(h->TestAlloc(fl-min+1)==p[i]);
			test(h->Top() == top);
			test(h->AllocLen(p[i])==fl);
			h->TestFree(p[i]);
			// ensure free cell is created this time as well as alloc'd cell
			test(h->TestAlloc(fl-min)==p[i]);
			test(h->Top() == top);
			q = (TUint8*)p[i] + fl - min + RHeap::EAllocCellSize;
			test(h->FreeCellLen(q) == min - RHeap::EAllocCellSize);
			test(h->TestAlloc(0) == q);
			test(h->Top() == top);
			h->TestFree(p[i]);
			test(h->FreeCellLen(p[i]) == fl - min);
			h->TestFree(q);
			test(h->FreeCellLen(q) < 0);
			test(h->FreeCellLen(p[i]) == fl);
			// realloc all cells and check heap not expanded
			test(h->TestAlloc(al)==p[i]);
			test(h->Top() == top);
			test(h->TestAlloc(al)==p[j]);
			test(h->Top() == top);
			test(h->TestAlloc(al)==p[k]);
			test(h->Top() == top);
			// If padding than no space should left on heap
			if (pad)
				test(h->FreeRef().next == NULL);
			}
		// when padding this will free padding from top of heap
		h->TestFree(last);
		}
	h->FullCheck();
	}

void DoTest3(RHeap* aH)
	{
	RTestHeap* h = (RTestHeap*)aH;
	test.Printf(_L("Test ReAlloc: min=%x max=%x align=%d growby=%d\n"),
						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());
	// allocate continuous heap cell, then free them and reallocate again
	TInt al;
	for (al=1; al<256; al+=al+1)
		{
		TAny* p0 = h->TestAlloc(al);
		TInt al0 = h->AllocLen(p0);
		h->TestFree(p0);
		TAny* p1 = h->TestReAlloc(NULL, al, 0);
		TInt al1 = h->AllocLen(p1);
		test(p1 == p0);
		test(al1 == al0);
		h->TestFree(p1);
		TAny* p2 = h->TestAlloc(1);
		TAny* p3 = h->TestReAlloc(p2, al, 0);
		test(p3 == p0);
		TInt al3 = h->AllocLen(p3);
		test(al3 == al0);
		h->TestFree(p3);
		TAny* p4 = h->TestAlloc(1024);
		TAny* p5 = h->TestReAlloc(p4, al, 0);
		test(p5 == p0);
		TInt al5 = h->AllocLen(p5);
		test(al5 == al0);
		h->TestFree(p5);
		}
	TInt i;
	TInt j;
	for (j=0; j<30; j+=3)
		{
		TAny* p[30];
		TInt ala[30];
		TInt fla[30];
		h->Reset();
		for (i=0; i<30; ++i)
			{
			p[i] = h->TestAlloc(8*i*i);
			ala[i] = h->AllocLen(p[i]);
			fla[i] = 0;
			}
		for (i=1; i<30; i+=3)
			{
			h->TestFree(p[i]);
			fla[i] = h->FreeCellLen(p[i]);
			test(fla[i] == ala[i]);
			test(h->FreeCellLen(p[i-1]) < 0);
			test(h->FreeCellLen(p[i+1]) < 0);
			}
		h->FullCheck();
		TInt al1 = _ALIGN_UP(Max((RHeap::EAllocCellSize + 1), h->MinCell()), h->Align());
		// adjust al1 for some case when reallocated heap cell will not be shrinked because remainder will not big enough
		// to form a new free cell due to a big KHeapMinCellSize value
		TInt alaj = ala[j] + RHeap::EAllocCellSize;
		if (al1 < alaj && alaj - al1 < h->MinCell())
			al1 = alaj;
		TAny* p1 = h->TestReAlloc(p[j], 1, RHeap::ENeverMove);
		test(p1 == p[j]);
		test(h->AllocLen(p1) == al1 - RHeap::EAllocCellSize);
		TAny* p1b = (TUint8*)p1 + al1;
		test(h->FreeCellLen(p1b) == fla[j+1] + RHeap::EAllocCellSize + ala[j] - al1);
		TInt l2 = ala[j] + fla[j+1] + RHeap::EAllocCellSize; // max without moving
		TInt l3 = l2 - h->MinCell();
		TAny* p3 = h->TestReAlloc(p[j], l3, RHeap::ENeverMove);
		test(p3 == p[j]);
		TAny* p3b = (TUint8*)p3 + h->AllocLen(p3) + RHeap::EAllocCellSize;
		test(h->FreeCellLen(p3b) == h->MinCell() - RHeap::EAllocCellSize);
		TAny* p2 = h->TestReAlloc(p[j], l2, RHeap::ENeverMove);
		test(p2 == p[j]);
		test(h->AllocLen(p2) == l2);
		TAny* p4 = h->TestReAlloc(p[j], l2+1, RHeap::ENeverMove);
		test(p4 == NULL);
		test(h->AllocLen(p2) == l2);
		TAny* p5 = h->TestReAlloc(p[j], l2+1, 0);
		TInt k = 0;
		for (; k<30 && fla[k] <= l2; ++k) {}
		if (k < 30)
			test(p5 == p[k]);
		else
			test(p5 >= (TUint8*)p[29] + ala[29]);
		test(h->FreeCellLen(p2) == ala[j] + ala[j+1] + RHeap::EAllocCellSize);
		TInt ali = _ALIGN_UP(RHeap::EAllocCellSize,h->Align());
		TAny* p6b = (TUint8*)p[j+2] + ala[j+2] - ali + RHeap::EAllocCellSize;
		test(h->FreeCellLen(p6b) < 0);
		TAny* p6 = h->TestReAlloc(p[j+2], ala[j+2] - ali , 0);
		test(p6 == p[j+2]);
		if (h->AllocLen(p6) != ala[j+2]) // allocated heap cell size changed
			test(h->FreeCellLen(p6b) == h->MinCell() - RHeap::EAllocCellSize);
		TInt g = h->GrowBy();
		TAny* p7 = h->TestReAlloc(p5, 8*g, 0);
		test(p7 >= p5);
		TUint8* p8 = (TUint8*)p7 - RHeap::EAllocCellSize + al1;
		TUint8* p9 = (TUint8*)_ALIGN_UP(TLinAddr(p8), h->PageSize());
		if (p9-p8 < h->MinCell())
			p9 += h->PageSize();
		TAny* p7b = h->TestReAlloc(p7, 1, 0);
		test(p7b == p7);
		test(h->Top() + (RHeap::EAllocCellSize & (h->Align()-1)) == p9);

		h->FullCheck();
		}
	}

// Test compression
// {1 free cell, >1 free cell} x {reduce cell, eliminate cell, reduce cell but too small}
//
void DoTest4(RHeap* aH)
	{
	RTestHeap* h = (RTestHeap*)aH;
	test.Printf(_L("Test Compress: min=%x max=%x align=%d growby=%d\n"),
						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());
	TInt page_size;
	UserHal::PageSizeInBytes(page_size);
	test(page_size == h->PageSize());
	TInt g = h->GrowBy();
	TEST_ALIGN(g, page_size);
	test(g >= page_size);
	RChunk c;
	c.SetHandle(h->ChunkHandle());
	TInt align = h->Align();
	TInt minc = h->MinCell();

	TInt orig_size = c.Size();
	TUint8* orig_top = h->Top();

	// size in bytes that last free cell on the top of the heap must be 
	// before the heap will be shrunk, size must include the no of bytes to
	// store the cell data/header i.e RHeap::EAllocCellSize
	TInt shrinkThres = KHeapShrinkHysRatio*(g>>8);

	TInt pass;
	for (pass=0; pass<2; ++pass)
		{
		TUint8* p0 = (TUint8*)h->TestAlloc(4);
		test(p0 == h->Base() + RHeap::EAllocCellSize);
		TInt l1 = h->Top() - (TUint8*)h->FreeRef().next;
		TEST_ALIGN(l1, align);
		l1 -= RHeap::EAllocCellSize;
		TUint8* p1;
		// Grow heap by 2*iGrowBy bytes
		p1 = (TUint8*)h->TestAlloc(l1 + 2*g);
		test(p1 == p0 + h->AllocLen(p0) + RHeap::EAllocCellSize);
		test(h->Top() - orig_top == 2*g);
		test(c.Size() - orig_size == 2*g);
		// May compress heap, may not
		h->TestFree(p1);
		h->ForceCompress(2*g);
		test(h->Top() == orig_top);
		test(c.Size() == orig_size);
		test((TUint8*)h->FreeRef().next == p1 - RHeap::EAllocCellSize);
		h->FullCheck();
		//if KHeapShrinkHysRatio is > 2.0 then heap compression will occur here
		test(h->Compress() == 0);
		test(h->TestAlloc(l1) == p1);
		test(h->FreeRef().next == NULL);
		if (pass)
			h->TestFree(p0);	// leave another free cell on second pass
		TInt l2 = g - RHeap::EAllocCellSize;
		// Will grow heap by iGrowBy bytes
		TUint8* p2 = (TUint8*)h->TestAlloc(l2);
		test(p2 == orig_top + RHeap::EAllocCellSize);
		test(h->Top() - orig_top == g);
		test(c.Size() - orig_size == g);
		// may or may not compress heap
		h->TestFree(p2);
		if (l2+RHeap::EAllocCellSize >= shrinkThres)
			{
			// When KHeapShrinkRatio small enough heap will have been compressed
			test(h->Top() == orig_top);			
			if (pass)
				{
				test((TUint8*)h->FreeRef().next == p0 - RHeap::EAllocCellSize);
				test((TUint8*)h->FreeRef().next->next == NULL);
				}
			else
				test((TUint8*)h->FreeRef().next == NULL);
			}
		else
			{			
			test(h->Top() - orig_top == g);
			if (pass)
				{
				test((TUint8*)h->FreeRef().next == p0 - RHeap::EAllocCellSize);
				test((TUint8*)h->FreeRef().next->next == orig_top);
				}
			else
				test((TUint8*)h->FreeRef().next == orig_top);
			}
		// this compress will only do anything if the KHeapShrinkRatio is large 
		// enough to introduce hysteresis otherwise the heap would have been compressed 
		// by the free operation itself
		TInt tmp1,tmp2;
		tmp2=h->CalcComp(g);
		tmp1=h->Compress();
		test(tmp1 == tmp2);
		test(h->Top() == orig_top);
		test(c.Size() == orig_size);
		h->FullCheck();
		// shouldn't compress heap as already compressed
		test(h->Compress() == 0);
		//grow heap by iGrowBy bytes
		test(h->TestAlloc(l2) == p2);
		//grow heap by iGrowBy bytes
		TUint8* p3 = (TUint8*)h->TestAlloc(l2);
		test(p3 == p2 + g);
		test(h->Top() - orig_top == 2*g);
		test(c.Size() - orig_size == 2*g);
		// may or may not reduce heap
		h->TestFree(p2);
		// may or may not reduce heap
		h->TestFree(p3);
		h->ForceCompress(2*g);
		test(h->Top() == orig_top);
		test(c.Size() == orig_size);
		h->FullCheck();
		if (pass)
			{
			test((TUint8*)h->FreeRef().next == p0 - RHeap::EAllocCellSize);
			test((TUint8*)h->FreeRef().next->next == NULL);
			}
		else
			test((TUint8*)h->FreeRef().next == NULL);
		//grow heap by iGrowBy bytes
		test(h->TestAlloc(l2) == p2);
		//grow heap by iGrowBy*2 + page size bytes
		test(h->TestAlloc(l2 + g + page_size) == p3);
		test(h->Top() - orig_top == 4*g);
		test(c.Size() - orig_size == 4*g);
		// will compress heap if KHeapShrinkHysRatio <= KHeapShrinkRatioDflt
		test(h->TestReAlloc(p3, page_size - RHeap::EAllocCellSize, 0) == p3);
		h->ForceCompress(g+page_size);
		test(h->Top() - orig_top == g + page_size);
		test(c.Size() - orig_size == g + page_size);
		h->FullCheck();
		// will compress heap if KHeapShrinkHysRatio <= KHeapShrinkRatio1
		h->TestFree(p2);
		// will compress heap if KHeapShrinkHysRatio <= KHeapShrinkRatio1 && g<=page_size
		// or KHeapShrinkHysRatio >= 2.0 and g==page_size
		h->TestFree(p3);
		// may or may not perform further compression
		tmp1=h->CalcComp(g+page_size);
		tmp2=h->Compress();
		test(tmp1 == tmp2);
		test(h->Top() == orig_top);
		test(c.Size() == orig_size);
		h->FullCheck();
		test(h->TestAlloc(l2 - minc) == p2);
		test(h->TestAlloc(l2 + g + page_size + minc) == p3 - minc);
		test(h->Top() - orig_top == 4*g);
		test(c.Size() - orig_size == 4*g);
		h->TestFree(p3 - minc);
		h->ForceCompress(l2 + g + page_size + minc);
		test(h->Top() - orig_top == g);
		test(c.Size() - orig_size == g);
		h->FullCheck();
		if (pass)
			{
			test((TUint8*)h->FreeRef().next == p0 - RHeap::EAllocCellSize);
			test((TUint8*)h->FreeRef().next->next == p3 - minc - RHeap::EAllocCellSize);
			}
		else
			test((TUint8*)h->FreeRef().next == p3 - minc - RHeap::EAllocCellSize);
		h->TestFree(p2);
		if (l2+RHeap::EAllocCellSize >= shrinkThres)
			{
			// When KHeapShrinkRatio small enough heap will have been compressed
			test(h->Top() == orig_top);
			test(c.Size() - orig_size == 0);
			}
		else
			{
			test(h->Top() - orig_top == g);
			test(c.Size() - orig_size == g);
			}
		h->FullCheck();
		if ( ((TLinAddr)orig_top & (align-1)) == 0)
			{
			TAny* free;
			TEST_ALIGN(p2 - RHeap::EAllocCellSize, page_size);
			// will have free space of g-minc
			test(h->TestAlloc(l2 + minc) == p2);
			test(h->Top() - orig_top == 2*g);
			test(c.Size() - orig_size == 2*g);
			free = pass ? h->FreeRef().next->next : h->FreeRef().next;
			test(free != NULL);
			test(h->TestReAlloc(p2, l2 - 4, 0) == p2);
			TInt freeSp = g-minc + (l2+minc - (l2-4));
			TInt adjust = 0;
			if (freeSp >= shrinkThres && freeSp-page_size >= minc)
				{
				// if page_size is less than growBy (g) then heap will be shrunk
				// by less than a whole g.
				adjust = g-((page_size<g)?page_size:0);
				}
			test(h->Top() - orig_top == 2*g - adjust);
			test(c.Size() - orig_size == 2*g - adjust);
			free = pass ? h->FreeRef().next->next : h->FreeRef().next;
			test(free != NULL);
			TEST_ALIGN(TLinAddr(free)+4, page_size);
			test(h->TestAlloc(l2 + g + page_size + 4) == p3 - 4);
			test(h->Top() - orig_top == 4*g - adjust);
			test(c.Size() - orig_size == 4*g - adjust);
			h->TestFree(p3 - 4);
			h->ForceCompress(l2 + g + page_size + 4);
			test(h->Top() - orig_top == g + page_size);
			test(c.Size() - orig_size == g + page_size);
			h->FullCheck();
			h->TestFree(p2);
			h->ForceCompress(l2-4);
			test(h->Compress() == 0);
			// check heap is grown, will have free space of g-minc
			test(h->TestAlloc(l2 + minc) == p2);
			test(h->Top() - orig_top == 2*g);
			test(c.Size() - orig_size == 2*g);
			free = pass ? h->FreeRef().next->next : h->FreeRef().next;
			test(free != NULL);
			// may shrink heap as will now have g+minc free bytes
			test(h->TestReAlloc(p2, l2 - minc, 0) == p2);
			if (g+minc >= shrinkThres)
				{
				test(h->Top() - orig_top == g);
				test(c.Size() - orig_size == g);
				}
			else
				{
				test(h->Top() - orig_top == 2*g);
				test(c.Size() - orig_size == 2*g);
				}
			free = pass ? h->FreeRef().next->next : h->FreeRef().next;
			test(free != NULL);
			TEST_ALIGN(TLinAddr(free)+minc, page_size);
			test(h->TestAlloc(l2 + g + page_size + minc) == p3 - minc);
			test(h->Top() - orig_top == 4*g);
			test(c.Size() - orig_size == 4*g);
			h->TestFree(p3 - minc);
			h->ForceCompress(l2 + g + page_size + minc);
			test(h->Top() - orig_top == g);
			test(c.Size() - orig_size == g);
			h->FullCheck();
			h->TestFree(p2);
			}

		h->TestFree(p1);
		if (pass == 0)
			h->TestFree(p0);
		h->Compress();
		}
	h->FullCheck();
	}

void Test1()
	{
	RHeap* h;
	h = RTestHeap::FixedHeap(0x1000, 0);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = RTestHeap::FixedHeap(0x1000, 0, EFalse);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = RTestHeap::FixedHeap(0x10000, 64);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = RTestHeap::FixedHeap(0x100000, 4096);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = RTestHeap::FixedHeap(0x100000, 8192);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x1000, 0x1000, 4);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x10000, 0x1000, 4);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 4096);
	test(h != NULL);
	DoTest1(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 4);
	test(h != NULL);
	DoTest1(h);
	h->Reset();
	DoTest2(h);
	h->Reset();
	DoTest3(h);
	h->Reset();
	DoTest4(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 8);
	test(h != NULL);
	DoTest1(h);
	h->Reset();
	DoTest2(h);
	h->Reset();
	DoTest3(h);
	h->Reset();
	DoTest4(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 16);
	test(h != NULL);
	DoTest1(h);
	h->Reset();
	DoTest2(h);
	h->Reset();
	DoTest3(h);
	h->Reset();
	DoTest4(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 32);
	test(h != NULL);
	DoTest1(h);
	h->Reset();
	DoTest2(h);
	h->Reset();
	DoTest3(h);
	h->Reset();
	DoTest4(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x3000, 0x100000, 0x3000, 4);
	test(h != NULL);
	DoTest1(h);
	h->Reset();
	DoTest2(h);
	h->Reset();
	DoTest3(h);
	h->Reset();
	DoTest4(h);
	h->Close();
	}

struct SHeapStress
	{
	RThread iThread;
	volatile TBool iStop;
	TInt iAllocs;
	TInt iFailedAllocs;
	TInt iFrees;
	TInt iReAllocs;
	TInt iFailedReAllocs;
	TInt iChecks;
	TUint32 iSeed;
	RAllocator* iAllocator;

	TUint32 Random();
	};

TUint32 SHeapStress::Random()
	{
	iSeed *= 69069;
	iSeed += 41;
	return iSeed;
	}

TInt RandomLength(TUint32 aRandom)
	{
	TUint8 x = (TUint8)aRandom;
	if (x & 0x80)
		return (x & 0x7f) << 7;
	return x & 0x7f;
	}

TInt HeapStress(TAny* aPtr)
	{
	SHeapStress& hs = *(SHeapStress*)aPtr;
	RTestHeap* h = (RTestHeap*)&User::Allocator();
	TUint8* cell[256];
	TInt len[256];

	Mem::FillZ(cell, sizeof(cell));
	Mem::FillZ(len, sizeof(len));

	RThread::Rendezvous(KErrNone);
	while (!hs.iStop)
		{
		// allocate all cells
		TInt i;
		for (i=0; i<256; ++i)
			{
			if (!cell[i])
				{
				++hs.iAllocs;
				cell[i] = (TUint8*)h->TestAlloc(RandomLength(hs.Random()));
				if (cell[i])
					len[i] = h->AllocLen(cell[i]);
				else
					++hs.iFailedAllocs;
				}
			}

		// free some cells
		TInt n = 64 + (hs.Random() & 127);
		while (--n)
			{
			i = hs.Random() & 0xff;
			if (cell[i])
				{
				test(h->AllocLen(cell[i]) == len[i]);
				h->TestFree(cell[i]);
				cell[i] = NULL;
				len[i] = 0;
				++hs.iFrees;
				}
			}

		// realloc some cells
		n = 64 + (hs.Random() & 127);
		while (--n)
			{
			TUint32 rn = hs.Random();
			i = (rn >> 8) & 0xff;
			TInt new_len = RandomLength(rn);
			if (cell[i])
				{
				test(h->AllocLen(cell[i]) == len[i]);
				++hs.iReAllocs;
				TUint8* p = (TUint8*)h->TestReAlloc(cell[i], new_len, rn >> 16);
				if (p)
					{
					cell[i] = p;
					len[i] = h->AllocLen(p);
					}
				else
					++hs.iFailedReAllocs;
				}
			}

		// check the heap
		h->Check();
		++hs.iChecks;
		}
	return 0;
	}

void CreateStressThread(SHeapStress& aInfo)
	{
	Mem::FillZ(&aInfo, _FOFF(SHeapStress, iSeed));
	RThread& t = aInfo.iThread;
	TInt r = t.Create(KNullDesC(), &HeapStress, 0x2000, aInfo.iAllocator, &aInfo);
	test(r==KErrNone);
	t.SetPriority(EPriorityLess);
	TRequestStatus s;
	t.Rendezvous(s);
	test(s == KRequestPending);
	t.Resume();
	User::WaitForRequest(s);
	test(s == KErrNone);
	test(t.ExitType() == EExitPending);
	t.SetPriority(EPriorityMuchLess);
	}

void StopStressThread(SHeapStress& aInfo)
	{
	RThread& t = aInfo.iThread;
	TRequestStatus s;
	t.Logon(s);
	aInfo.iStop = ETrue;
	User::WaitForRequest(s);
	const TDesC& exitCat = t.ExitCategory();
	TInt exitReason = t.ExitReason();
	TInt exitType = t.ExitType();
	test.Printf(_L("Exit type %d,%d,%S\n"), exitType, exitReason, &exitCat);
	test(exitType == EExitKill);
	test(exitReason == KErrNone);
	test(s == KErrNone);
	test.Printf(_L("Total Allocs    : %d\n"), aInfo.iAllocs);
	test.Printf(_L("Failed Allocs   : %d\n"), aInfo.iFailedAllocs);
	test.Printf(_L("Total Frees		: %d\n"), aInfo.iFrees);
	test.Printf(_L("Total ReAllocs  : %d\n"), aInfo.iReAllocs);
	test.Printf(_L("Failed ReAllocs : %d\n"), aInfo.iFailedReAllocs);
	test.Printf(_L("Heap checks     : %d\n"), aInfo.iChecks);
	}

void DoStressTest1(RAllocator* aAllocator)
	{
	RTestHeap* h = (RTestHeap*)aAllocator;
	test.Printf(_L("Test Stress 1: min=%x max=%x align=%d growby=%d\n"),
						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());
	SHeapStress hs;
	hs.iSeed = 0xb504f334;
	hs.iAllocator = aAllocator;
	CreateStressThread(hs);
	User::After(10*1000000);
	StopStressThread(hs);
	CLOSE_AND_WAIT(hs.iThread);
	h->FullCheck();
	}

void DoStressTest2(RAllocator* aAllocator)
	{
	RTestHeap* h = (RTestHeap*)aAllocator;
	test.Printf(_L("Test Stress 2: min=%x max=%x align=%d growby=%d\n"),
						h->MinLength(), h->MaxLength(), h->Align(), h->GrowBy());
	SHeapStress hs1;
	SHeapStress hs2;
	hs1.iSeed = 0xb504f334;
	hs1.iAllocator = aAllocator;
	hs2.iSeed = 0xddb3d743;
	hs2.iAllocator = aAllocator;
	CreateStressThread(hs1);
	CreateStressThread(hs2);
	User::After(20*1000000);
	StopStressThread(hs1);
	StopStressThread(hs2);
	CLOSE_AND_WAIT(hs1.iThread);
	CLOSE_AND_WAIT(hs2.iThread);
	h->FullCheck();
	}

void StressTests()
	{
	RHeap* h;
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 4);
	test(h != NULL);
	DoStressTest1(h);
	h->Reset();
	DoStressTest2(h);
	h->Close();
	h = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x100000, 0x1000, 8);
	test(h != NULL);
	DoStressTest1(h);
	h->Reset();
	DoStressTest2(h);
	h->Close();
	}
		
TInt TestHeapGrowInPlace(TInt aMode)
    {
    TBool reAllocs=EFalse;
    TBool heapGrew=EFalse;
    
    RHeap* myHeap;
    
    myHeap = UserHeap::ChunkHeap(NULL,0x1000,0x4000,0x1000);
    
    TAny *testBuffer,*testBuffer2;
    // Start size chosen so that 1st realloc will use up exactly all the heap.
    // Later iterations wont, and there will be a free cell at the end of the heap.
    TInt currentSize = ((0x800) - sizeof(RHeap)) - RHeap::EAllocCellSize;
    TInt growBy = 0x800;
    TInt newSpace, space;
    
    testBuffer2 = myHeap->Alloc(currentSize);

    newSpace = myHeap->Size();
    do 
    {
    	space = newSpace;
		testBuffer = testBuffer2;
	    currentSize+=growBy;
		testBuffer2 = myHeap->ReAlloc(testBuffer,currentSize,aMode);	
		
		newSpace = myHeap->Size();
		
		if (testBuffer2) 
			{
				
			if (testBuffer!=testBuffer2)
					reAllocs = ETrue;
				
			if (newSpace>space)
					heapGrew = ETrue;
			}
		growBy-=16;
 	} while (testBuffer2);
    currentSize-=growBy;	
    
    myHeap->Free(testBuffer);
    myHeap->Close();
    
    // How did we do?
    if (reAllocs) 
    	{
    	test.Printf(_L("Failure - Memory was moved!\n"));
    	return -100;
    	}
    if (!heapGrew) 
    	{
    	test.Printf(_L("Failure - Heap Never Grew!\n"));
    	return -200;
    	}
    if (currentSize<= 0x3000) 
    	{
    	test.Printf(_L("Failed to grow by a reasonable amount!\n"));
    	return -300;
    	}
        
    return KErrNone;
    }
    
void ReAllocTests()
	{
	test.Next(_L("Testing Grow In Place"));
	test(TestHeapGrowInPlace(0)==KErrNone);
    test(TestHeapGrowInPlace(RHeap::ENeverMove)==KErrNone);
	}

RHeap* TestDEF078391Heap = 0;

TInt TestDEF078391ThreadFunction(TAny*)
	{
    TestDEF078391Heap = UserHeap::ChunkHeap(NULL,0x1000,0x100000,KMinHeapGrowBy,0,EFalse);
	return TestDEF078391Heap ? KErrNone : KErrGeneral;
	}

void TestDEF078391()
	{
	// Test that creating a multithreaded heap with UserHeap::ChunkHeap
	// doesn't create any reference counts on the creating thread.
	// This is done by creating a heap in a named thread, then exiting
	// the thread and re-creating it with the same name.
	// This will fail with KErrAlreadyExists if the orinal thread has
	// not died because of an unclosed reference count.
	test.Next(_L("Test that creating a multithreaded heap doesn't open references of creator"));
	_LIT(KThreadName,"ThreadName");
	RThread t;
	TInt r=t.Create(KThreadName,TestDEF078391ThreadFunction,0x1000,0x1000,0x100000,NULL);
	test(r==KErrNone);
	TRequestStatus status;
	t.Logon(status);
	t.Resume();
	User::WaitForRequest(status);
	test(status==KErrNone);
	test(t.ExitType()==EExitKill);
	test(t.ExitReason()==KErrNone);
	CLOSE_AND_WAIT(t);
	test(TestDEF078391Heap!=0);
	User::After(1000000); // give more opportunity for thread cleanup to happen

	// create thread a second time
	r=t.Create(KThreadName,TestDEF078391ThreadFunction,0x1000,0x1000,0x100000,NULL);
	test(r==KErrNone);
	t.Kill(0);
	CLOSE_AND_WAIT(t);

	// close the heap that got created earlier
	TestDEF078391Heap->Close();
	}

TInt E32Main()
	{
	test.Title();
	__KHEAP_MARK;
	test.Start(_L("Testing heaps"));
	TestDEF078391();
	Test1();
	StressTests();
	ReAllocTests();
	test.End();
	__KHEAP_MARKEND;
	return 0;
	}