// Copyright (c) 1995-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_heap.cpp

// Overview:

// Tests RHeap class.

// API Information:

// RHeap

// Details:

// - Test that the expected methods are in the DLL by calling each one.

// - Test heap auto expansion and compression by calling Alloc and Compress

// and verifying the results are as expected.

// - Verify the heap dump Base, Size, MinLength, Top and len values.

// - Test the RHeap AllocSize, Alloc, AllocLen, Count and Free methods. Verify

// results are as expected. Check heap object and confirm Invariant status.

// - For an RHeap object, test and verify the results of: allocate some cells, 

// free them with Reset, allocate some cells again, free them with Free, 

// allocate some cells again, free them backwards, allocate again, free the 

// odd cells then the even cells, allocate again, free one half then the other.

// Check heap object and confirm Invariant status.

// - For an RHeap object, test and verify the results of: attempt to resize a

// block above the space available, resize the block to 0, resize positively, 

// allocate a block, fill with data, allocate another block or two then resize

// the original block such that it has to be moved in memory, then check the 

// blocks' contents, test data was copied on reallocation, resize blocks and

// verify data integrity, expand and shrink, verify data.

// Check heap object and confirm Invariant status.

// - For an RHeap object, test and verify the results of: Alloc some cells,

// verify the Count, Check the object, Free some cells, verify the Count, 

// Check and Reset the object, corrupt the heap data and reset the object.

// - Test the leaving methods: AllocL and ReAllocL. Verify the results are as

// expected.

// - Test the RHeap methods: Alloc, Count, Size, Free and Close. Verify results

// are as expected.

// - Test sharing a chunk heap between two separate threads.  Each thread

// accesses the shared heap in a timed loop, to ensure that some true

// concurrency.

// - Test sharing a chunk heap between two separate threads. Run each thread in

// a timed loop, to ensure that some true concurrency. Each thread accesses

// the shared heap and results are verified.  The heap size is used to verify

// no leaks and that the largest available space is still available. The heap

// is checked to verify that no cells remain allocated after the tests are

// complete.

// - Test sharing a heap between two threads.  The thread whose heap it was is

// killed first.  Each thread accesses the shared heap and results are

// verified.

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

// Sets data for Test6

#define SetData(size)	pHeap->Reset();\

						Cell1=pHeap->Alloc(size);\

						Cell2=pHeap->Alloc(size);\

						Cell3=pHeap->Alloc(size);\

						for(pC=(TText8*)Cell1; pC<(TText8*)Cell1+pHeap->AllocLen(Cell1); *pC++='x');\

						for(pC=(TText8*)Cell2; pC<(TText8*)Cell2+pHeap->AllocLen(Cell2); *pC++='y');\

						for(pC=(TText8*)Cell3; pC<(TText8*)Cell3+pHeap->AllocLen(Cell3); *pC++='z');\

						OrigLen=pHeap->AllocLen(Cell2);			

// Tests cell contents for Test6

#define TestCells(Cell2Len)	for(pC=(TText8*)Cell1; pC<(TText8*)Cell1+pHeap->AllocLen(Cell1); test(*pC++=='x'));\

							for(pC=(TText8*)Cell2; pC<(TText8*)Cell2+Cell2Len; test(*pC++=='y'));\

							for(pC=(TText8*)Cell3; pC<(TText8*)Cell3+pHeap->AllocLen(Cell3); test(*pC++=='z'));\

							pHeap->Check();

#ifdef __EABI__

	IMPORT_D extern const TInt KHeapMinCellSize;

#else

    const TInt KHeapMinCellSize = 0;

#endif

const TInt KHeadSize = (TInt)RHeap::EAllocCellSize;

const TInt KAlign = _FOFF(RHeap::_s_align, d);

const TInt KMinCellLength = _ALIGN_UP((KHeapMinCellSize + Max(TInt(RHeap::EFreeCellSize),TInt(RHeap::EAllocCellSize))),KAlign) - RHeap::EAllocCellSize;

const TInt KMinFreeSize = _ALIGN_UP((KHeapMinCellSize + Max(TInt(RHeap::EFreeCellSize),TInt(RHeap::EAllocCellSize))),KAlign);

TInt PageSize;

class RTestHeap : public RHeap

	{

public:

	void __DbgTest(void* pRHeapDump) const;

	};

struct RHeapDump

	{

	TUint				iMinLength;

	RChunk				iChunk;

	TUint8				*iBase;

	TUint8				*iTop;

	RHeap::SCell		iFree;

	};

#pragma warning ( disable :4705 ) // statement has no effect

RHeapDump OrigDump;

#pragma warning ( default :4705 )

#if defined(_DEBUG)

void RTestHeap::__DbgTest(void* aPtr) const

	{

	RHeapDump& d = *(RHeapDump*)aPtr;

	d.iMinLength=iMinLength;

	d.iChunk.SetHandle(iChunkHandle);

	d.iBase=iBase;

	d.iTop=iTop;

	d.iFree=iFree;

	}

#endif

#if defined(_DEBUG)

TBool Invariant(RHeap* aHeap)

	{

	RHeapDump dump;

	((RTestHeap*)aHeap)->__DbgTest(&dump);

	if(dump.iMinLength!=OrigDump.iMinLength) 		return(EFalse);

	// Note: iChunk is a class

	if(dump.iBase!=OrigDump.iBase)			return(EFalse);

	if(*dump.iBase!=*OrigDump.iBase)		return(EFalse);

	if(dump.iTop!=OrigDump.iTop)			return(EFalse);

	if(dump.iTop[-1]!=OrigDump.iTop[-1])	return(EFalse);	

	if(dump.iFree.len!=OrigDump.iFree.len)	return(EFalse);

	// iFree.Next changes during allocation/freeing etc.

	return(ETrue);

	}

#define INV(x) x;

#else

#define INV(x)

#endif

LOCAL_D RTest test(_L("T_HEAP"));

LOCAL_D TInt heapCount=1;

LOCAL_D RHeap *gHeapPtr;

LOCAL_D RHeap *gHeapPtr2;

class TestRHeap

	{

public:

	void Test1(void);

	void Test2(void);

	void Test3(void);

	void Test4(void);

	void Test5(void);

	void Test7(void);

	void Test8(void);

	void TestCompressAll(void);

	void TestOffset(void);

private:

	TInt RHeapCalcReduce(TInt aCellSize, TInt aGrowBy);

	};

LOCAL_C RHeap* allocHeap(TInt aSize)

//

// Allocate a chunk heap with max size aSize

//

	{

	TName n;

	n.Format(_L("TESTHEAP%d"),heapCount++);

	return(User::ChunkHeap(&n,aSize,aSize));

	}

////////////////////////////////////////////////////////////////////////////////////////

// Test that methods are in the DLL

////////////////////////////////////////////////////////////////////////////////////////

void TestRHeap::Test1(void)

	{ 

	TAny* aCell;

	TInt aVar;

	RHeap* pHeap=allocHeap(3000); // tests first constructor indirectly 

	// constructor with Chunk not tested

	pHeap->Base();

	pHeap->Size();

	pHeap->Available(aVar);

	pHeap->Check();

	pHeap->Count();												 	

	pHeap->Count(aVar);

	aCell=pHeap->Alloc(50);

	pHeap->Free(aCell);

	aCell=pHeap->AllocL(50);

	pHeap->AllocLen(aCell);

	pHeap->ReAlloc(aCell, 100);

	pHeap->ReAllocL(aCell, 150);

	pHeap->Reset();

	pHeap->Close();

	}

///////////////////////////////////////////////////////////////////////////////

// Test Assorted Methods 1

//////////////////////////////////////////////////////////////////////////////

void TestRHeap::Test2(void)

	{

#if defined(_DEBUG)

	RHeapDump dump;

	RHeap* pHeap=allocHeap(3000);

	((RTestHeap*)pHeap)->__DbgTest(&OrigDump);

	((RTestHeap*)pHeap)->__DbgTest(&dump);

	test(dump.iBase==pHeap->Base());

	test((dump.iTop-dump.iBase)==pHeap->Size());

	pHeap->Check();

	test(Invariant(pHeap));

	pHeap->Close();

#endif

	}

///////////////////////////////////////////////////////////////////////////////

// Test Assorted Methods 2

//////////////////////////////////////////////////////////////////////////////		 

void TestRHeap::Test3(void)

	{  

	TInt CellLen;

	TInt OrigBiggestBlock, BiggestBlock;

	TAny* aCell;

	TInt FreeCount, AllocCount, AllocSize;

	RHeap* pHeap=allocHeap(5000);

#if defined(_DEBUG)

	((RTestHeap*)pHeap)->__DbgTest(&OrigDump);

#endif

	// test AllocSize

	AllocCount=pHeap->Count(FreeCount);

	test(pHeap->AllocSize(AllocSize)==pHeap->Count());

	test(AllocSize==0);

	test(AllocCount==pHeap->Count());

	test(AllocCount==0);

	test(FreeCount==1);

	TAny* p1=pHeap->Alloc(1);

	test(pHeap->AllocSize(AllocSize)==1);

	test(AllocSize==pHeap->AllocLen(p1));

	TAny* p2=pHeap->Alloc(8);

	test(pHeap->AllocSize(AllocSize)==2);

	test(AllocSize==pHeap->AllocLen(p1)+pHeap->AllocLen(p2));

	TAny* p3=pHeap->Alloc(127);

	test(pHeap->AllocSize(AllocSize)==3);

	test(AllocSize==pHeap->AllocLen(p1)+pHeap->AllocLen(p2)+pHeap->AllocLen(p3));

	pHeap->Free(p2);

	test(pHeap->AllocSize(AllocSize)==2);

	test(AllocSize==pHeap->AllocLen(p1)+pHeap->AllocLen(p3));

	pHeap->Free(p1);

	test(pHeap->AllocSize(AllocSize)==1);

	test(AllocSize==pHeap->AllocLen(p3));

	pHeap->Free(p3);

	test(pHeap->AllocSize(AllocSize)==0);

	test(AllocSize==0);

	pHeap->Available(OrigBiggestBlock);

	// Request too large a block 

	test((aCell=pHeap->Alloc(OrigBiggestBlock+1))==NULL);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==0);

	test(FreeCount==1);

	// Request block same size as that available

	test((aCell=pHeap->Alloc(OrigBiggestBlock))!=NULL);

	test(pHeap->Available(BiggestBlock)==0);  

	test(BiggestBlock==0);

	test(pHeap->AllocLen(aCell)==OrigBiggestBlock);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==pHeap->Count());

	test(AllocCount==1);

	test(FreeCount==0);

	pHeap->Check();

	// Free the block

	pHeap->FreeZ(aCell);

	test(aCell==NULL);

	pHeap->Available(BiggestBlock);

	test(BiggestBlock==OrigBiggestBlock);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==0);

	test(FreeCount==1);

	// Request a block much smaller than that available

	test((aCell=pHeap->Alloc(1))!=NULL);

	CellLen=pHeap->AllocLen(aCell);

	pHeap->Available(BiggestBlock);

	test(pHeap->Available(BiggestBlock)==BiggestBlock);

	test((BiggestBlock+CellLen+KHeadSize)==OrigBiggestBlock);

	// NOTE: if a block of 1000 was initially available, getting a cell of length 100 DOES NOT

	// leave 900 available as some of the 1000(KHeadSize) is used up storing the length of the

	// allocated block

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==1);

	test(FreeCount==1);

	pHeap->Check();

	// Free the block

	pHeap->Free(aCell);

	test(aCell!=NULL);

	pHeap->Available(BiggestBlock);

	test(BiggestBlock==OrigBiggestBlock);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==0);

	test(FreeCount==1);

	// Request a block only just smaller than that available

	test((aCell=pHeap->Alloc(OrigBiggestBlock-1))!=NULL);

	CellLen=pHeap->AllocLen(aCell);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==1);

	test(FreeCount==0);

	pHeap->Check();

	// Free the block

	pHeap->Free(aCell);

	pHeap->Available(BiggestBlock);

	test(BiggestBlock==OrigBiggestBlock);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==0);

	test(FreeCount==1);

	//Request a block of 0 size	   Note: 0 may not necessarily be allocated (probably will be 4)

	test((aCell=pHeap->Alloc(0))!=NULL);

	pHeap->Available(BiggestBlock);

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==1);

	test(FreeCount==1);

	pHeap->Check();

	//Free the block

	pHeap->Free(aCell);

	pHeap->Available(BiggestBlock);

	test(BiggestBlock==OrigBiggestBlock);	 

	AllocCount=pHeap->Count(FreeCount);

	test(AllocCount==0);

	test(FreeCount==1);

	pHeap->Check();

	INV(test(Invariant(pHeap)));

	// close heap so we don't exceed chunk limit

	pHeap->Close();

	}

///////////////////////////////////////////////////////////////////////////////

// Test Assorted Methods 3 - Here we go loopy loo, here we go loopy li

//////////////////////////////////////////////////////////////////////////////				  

void TestRHeap::Test4(void)

	{ 

	TInt OrigBiggestBlock, BiggestBlock, FreeCount, AllocCount;

	RHeap* pHeap=allocHeap(5000);

	pHeap->Available(OrigBiggestBlock);

#if defined(_DEBUG)

	((RTestHeap*)pHeap)->__DbgTest(&OrigDump);

#endif

	for(TInt ArraySize=1; ArraySize<=100; ArraySize++)

		{	  

		TAny** ArrayOfCells;

		ArrayOfCells= new TAny*[ArraySize];

		TInt ArrayIndex;

		// Allocate some cells

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			ArrayOfCells[ArrayIndex]=pHeap->Alloc(OrigBiggestBlock/(ArraySize*3)); 

		pHeap->Available(BiggestBlock);

		test(BiggestBlock!=OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test((TInt)AllocCount==ArraySize);

		test(FreeCount==1);

		pHeap->Check();

		// Now free them with Reset

		pHeap->Reset();

		pHeap->Available(BiggestBlock);

		test(BiggestBlock==OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test(AllocCount==0);

		test(FreeCount==1);

		// Allocate some cells again	 

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			ArrayOfCells[ArrayIndex]=pHeap->Alloc(OrigBiggestBlock/(ArraySize*3)); 

		pHeap->Available(BiggestBlock);

		test(BiggestBlock!=OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test((TInt)AllocCount==ArraySize);

		test(FreeCount==1);

		pHeap->Check();

		// Free them with Free

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		pHeap->Available(BiggestBlock);

		test(BiggestBlock==OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test(AllocCount==0);

		test(FreeCount==1);

		// Allocate some cells again	 

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			ArrayOfCells[ArrayIndex]=pHeap->Alloc(OrigBiggestBlock/(ArraySize*3));

		pHeap->Available(BiggestBlock);

		test(BiggestBlock!=OrigBiggestBlock); 

		AllocCount=pHeap->Count(FreeCount);

		test((TInt)AllocCount==ArraySize);

		test(FreeCount==1);

		pHeap->Check();

		// Free them backwards

		for(ArrayIndex=ArraySize-1; ArrayIndex>=0; ArrayIndex--)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		pHeap->Available(BiggestBlock);

		test(BiggestBlock==OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test(AllocCount==0);

		test(FreeCount==1);

		// Allocate some cells again	 

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			ArrayOfCells[ArrayIndex]=pHeap->Alloc(OrigBiggestBlock/(ArraySize*3));

		pHeap->Available(BiggestBlock);

		test(BiggestBlock!=OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test((TInt)AllocCount==ArraySize);

		test(FreeCount==1);

		pHeap->Check();

		// Free the odd cells then the even cells

		for(ArrayIndex=0; ArrayIndex<ArraySize; ArrayIndex+=2)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		pHeap->Check();

		for(ArrayIndex=1; ArrayIndex<ArraySize; ArrayIndex+=2)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		pHeap->Check();

		pHeap->Available(BiggestBlock);

		test(BiggestBlock==OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test(AllocCount==0);

		test(FreeCount==1);

		// Allocate some cells again	 

		for(ArrayIndex=0; ArrayIndex<ArraySize;ArrayIndex++)

			ArrayOfCells[ArrayIndex]=pHeap->Alloc(OrigBiggestBlock/(ArraySize*3));

		pHeap->Available(BiggestBlock);

		test(BiggestBlock!=OrigBiggestBlock);

		AllocCount=pHeap->Count(FreeCount);

		test((TInt)AllocCount==ArraySize);

		test(FreeCount==1);

		pHeap->Check();

		// Free one half then the other

		for(ArrayIndex=ArraySize-1; ArrayIndex>=ArraySize/2; ArrayIndex--)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		for(ArrayIndex=0; ArrayIndex<ArraySize/2; ArrayIndex++)

			pHeap->Free(ArrayOfCells[ArrayIndex]);

		AllocCount=pHeap->Count(FreeCount);

		test(AllocCount==0);

		test(FreeCount==1);

		delete [] ArrayOfCells;

		pHeap->Check();

		INV(test(Invariant(pHeap)))

		}

	// close heap so we don't exceed chunk limit

	pHeap->Close();

	}

///////////////////////////////////////////////////////////////////////////////

// Test ReAlloc

//////////////////////////////////////////////////////////////////////////////

void TestRHeap::Test5(void)

	{

	TInt BiggestBlock, CellSize;

	RHeap* pHeap=allocHeap(5000);

#if defined(_DEBUG)

	((RTestHeap*)pHeap)->__DbgTest(&OrigDump);

#endif

	pHeap->Available(BiggestBlock);

	TAny* aCell=pHeap->Alloc(BiggestBlock);

	// Attempt to resize the block above the space available

	test(pHeap->ReAlloc(aCell, BiggestBlock*2)==NULL);

	// Resize the block to 0

	aCell=pHeap->ReAlloc(aCell, 0);

	CellSize=pHeap->AllocLen(aCell);  // test?

	// Resize positively

	for(TInt aSize=0; aSize<=BiggestBlock; aSize++, pHeap->Available(BiggestBlock))

		{

		test(pHeap->ReAlloc(aCell, aSize)!=NULL); 

		CellSize=pHeap->AllocLen(aCell);

		test(CellSize>=aSize);

		if (aSize<KMinCellLength)

			test(CellSize==KMinCellLength);

		else

			test(CellSize<aSize+KAlign);

		}

	// Note: when increasing a cell size the size is rounded up to the nearest 4 but when 

	// decreasing a cell the size is rounded down to the nearest 8 - this is due to the fact

	// that when memory is released its size must be big enough to hold a free cell header which

	// is greater(8) than an allocated header(4)

	// i.e. size = 16, resize to 17 => result  is 20. But resize to 15 stays as 16, resize to 9

	// stays as 16 but resize as 8 will resize to 8