// 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_page_alloc.cpp

// Overview:

// Tests RHeap class.

// API Information:

// RHeap

// Details:

// - Tests that the page bitmap is consistent (i.e. encoded sizes are sensible and 

// encoded in the correct fashion.

// - Tests that pages which appear in the page bitmap are present in memory by 

// reading them.

// -Tests that other pages are not readable  

// - Tests page bitmap by creating an allocator where all allocations >= 4kB use

// paged allocator, allocating a large number of regions of various sizes (from

// 4 kB to b MB), checking that the walk function finds them all correctly, freeing

// some of them, checking the walk function again, and so on. 

// Platforms/Drives/Compatibility:

// All

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32hal.h>

#include <e32def.h>

#include <e32math.h>

#include <e32def_private.h>

#include "dla.h"

#include "slab.h"

#include "page_alloc.h"

#include "heap_hybrid.h"

struct TMetaData

    {

    TBool           iDLOnly;

    RFastLock*      iLock;

    TInt            iChunkSize;

    TInt            iSlabThreshold;

    unsigned        iSlabInitThreshold;

    unsigned        iSlabConfigBits;

    slab*           iPartialPage;

    slab*           iFullSlab;

    page*           iSparePage;

    TUint8*         iMemBase;

    unsigned char   iSizeMap[(MAXSLABSIZE>>2)+1];

    slabset         iSlabAlloc[MAXSLABSIZE>>2];

    slab**          iSlabAllocRealRootAddress[MAXSLABSIZE>>2];

    };

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

class TestHybridHeap

    {

public:

    static TUint8* MemBase(const RHybridHeap * aHybridHeap);

    static void GetHeapMetaData(RHeap& aHeap, TMetaData& aMeta);

    };

TUint8* TestHybridHeap::MemBase(const RHybridHeap * aHybridHeap)

	{

	return aHybridHeap->iMemBase;

	}

void TestHybridHeap::GetHeapMetaData(RHeap& aHeap, TMetaData& aMeta)

{

    RHybridHeap::STestCommand cmd;

    cmd.iCommand = RHybridHeap::EHeapMetaData;

    TInt ret = aHeap.DebugFunction(RHeap::EHybridHeap, &cmd, 0);

    test(ret == KErrNone);

    RHybridHeap* hybridHeap = (RHybridHeap*) cmd.iData;

    aMeta.iDLOnly              = hybridHeap->iDLOnly;

    aMeta.iLock                = &hybridHeap->iLock;

    aMeta.iChunkSize           = hybridHeap->iChunkSize;

    aMeta.iSlabThreshold       = hybridHeap->iSlabThreshold;

    aMeta.iSlabInitThreshold   = hybridHeap->iSlabInitThreshold;

    aMeta.iSlabConfigBits      = hybridHeap->iSlabConfigBits;

    aMeta.iPartialPage         = hybridHeap->iPartialPage;

    aMeta.iFullSlab            = hybridHeap->iFullSlab;

    aMeta.iSparePage           = hybridHeap->iSparePage;

    aMeta.iMemBase             = hybridHeap->iMemBase;

    TInt i;

    TInt count;

    count = sizeof(aMeta.iSizeMap)/sizeof(unsigned char);

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

        {

        aMeta.iSizeMap[i] = hybridHeap->iSizeMap[i];

        }

    count = sizeof(aMeta.iSlabAlloc)/sizeof(slabset);

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

        {

        aMeta.iSlabAlloc[i].iPartial = hybridHeap->iSlabAlloc[i].iPartial;

        aMeta.iSlabAllocRealRootAddress[i] = &hybridHeap->iSlabAlloc[i].iPartial;

        }

}

LOCAL_C void GetMeta(RHeap& aHeap, TMetaData& aMeta)

{

    TestHybridHeap::GetHeapMetaData(aHeap, aMeta);

}

class TestRHeap : public RHeap

	{

public:

	void InitTests();

	void Test1(void);

	void Test2(void);

	void Test3(void);

	void CloseTests();

	TUint GetRandomSize(TUint aMaxSize);

	TUint GetRandomIndex(TUint aMaxIndex);

	static void WalkCallback(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);

	TBool CheckWalkArrayEmpty();

private:

	RHybridHeap* iHybridHeap;

	RHeap *iHeap;

	TUint8* iMemBase;			     // bottom of Paged/Slab memory (chunk base)

	static TUint iWalkArraySize;

	static TUint iWalkArrayIndex;

	static TAny** iWalkArrayOfCells;

	TUint iAllocatedArrayIndex;

	TAny** iAllocatedArrayOfCells;

	};

TUint TestRHeap::iWalkArraySize = 100;

TUint TestRHeap::iWalkArrayIndex = 0;

TAny** TestRHeap::iWalkArrayOfCells = new TAny*[iWalkArraySize];

void TestRHeap::InitTests()

{

    // Allocate a chunk heap

	TPtrC testHeap=_L("TESTHEAP");

	iHeap=User::ChunkHeap(&testHeap,0x1800,0x800000); 

	RHybridHeap::STestCommand cmd;

	cmd.iCommand = RHybridHeap::EHeapMetaData;

	iHeap->DebugFunction(RHeap::EHybridHeap, &cmd, 0);

	iHybridHeap = (RHybridHeap*) cmd.iData;

	iMemBase = TestHybridHeap::MemBase(iHybridHeap);

	// configure paged heap threshold 16 kB

	cmd.iCommand = RHybridHeap::ESetConfig;

	cmd.iConfig.iSlabBits = 0x0; //0xabe

	cmd.iConfig.iDelayedSlabThreshold = 0x40000000;

	cmd.iConfig.iPagePower = 14;

	test(iHeap->DebugFunction(RHeap::EHybridHeap, &cmd, 0) == KErrNone);

}

TUint TestRHeap::GetRandomSize(TUint aMaxSize)

{

	TUint size = 0;

	do

	{

		size = Math::Random() & aMaxSize;

	}

	while(size < 16384 ||  size > aMaxSize );

	// subtract debug header size	

	return size - 8;	

}

TUint TestRHeap::GetRandomIndex(TUint aMaxIndex)

{

	TUint index = 0;

	do

	    {

        index = Math::Random() & 0x7F;

	    }

    while(index >= aMaxIndex || iWalkArrayOfCells[index] == 0);

	return index;

}

void TestRHeap::WalkCallback(TAny* aPtr, TCellType aCellType, TAny* aBuffer, TInt aLen)

{

    if (aLen>16375 && aPtr>0)    // Don't test DL allocator

        test(aCellType == EGoodAllocatedCell);

	TUint i = 0;

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

	{

		if(iWalkArrayOfCells[i] == aBuffer)

		{

			iWalkArrayOfCells[i] = NULL;

			break;

		}

	}

}

TBool TestRHeap::CheckWalkArrayEmpty()

{

	TUint i = 0;

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

	{

		if(iWalkArrayOfCells[i])

		{

			return EFalse;

		}

	}

	return ETrue;

}

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

// Test page allocation with various sizes, 16 kB - 8 MB //

// Simple test with fixed sizes.                         //

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

void TestRHeap::Test1(void)

{

	// Allocate and free single paged buffers of different size

	// Small buffer

	TAny* p1 = NULL;

	p1=iHeap->Alloc(0x4000);

	test(p1 != NULL && p1 >= iMemBase && p1 < iHybridHeap);

	test(iHeap->Count() == 1);

	iHeap->Free(p1);

	p1 = NULL;

	test(iHeap->Count() == 0);

	// Medium buffer

	p1=iHeap->Alloc(0x20000);

	test(p1 != NULL && p1 >= iMemBase && p1 < iHybridHeap);

	test(iHeap->Count() == 1);

	iHeap->Free(p1);

	p1 = NULL;

	test(iHeap->Count() == 0);

	// Large buffer

	p1=iHeap->Alloc(0x700000);

	test(p1 != NULL && p1 >= iMemBase && p1 < iHybridHeap);

	test(iHeap->Count() == 1);

	iHeap->Free(p1);

	p1 = NULL;

	test(iHeap->Count() == 0);

	// Oversized buffer, not allocated

	p1=iHeap->Alloc(0x900000);

	test(p1 == NULL);

	test(iHeap->Count() == 0);

}

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

// Allocate and free multiple random sized buffers, sizes under 65 kB.   //

// Check that all are allocated succesfully with Count. Free every other //

// of them, check the Count. Allocate more buffers sized under 655 kB    //

// and free all buffers in reverse order. Check all are freed.           //

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

void TestRHeap::Test2(void)

{

    TInt ArraySize=10;

	TInt ArrayIndex;

	TAny** ArrayOfCells;

	ArrayOfCells = new TAny*[ArraySize];

	// Allocate set of buffers

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

	{

		ArrayOfCells[ArrayIndex] = 0;

		ArrayOfCells[ArrayIndex] = iHeap->Alloc(GetRandomSize(0xFFFF));

		test(ArrayOfCells[ArrayIndex] != NULL);

	}

	test(iHeap->Count() == 10);

	// Free every other

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

	{

		iHeap->Free(ArrayOfCells[ArrayIndex]);

		ArrayOfCells[ArrayIndex] = 0;

	}

	test(iHeap->Count() == 5);

	TInt ArraySize2=10;

	TInt ArrayIndex2;

	TAny** ArrayOfCells2;

	ArrayOfCells2 = new TAny*[ArraySize2];

	// Allocate larger buffers

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

	{

		ArrayOfCells2[ArrayIndex2] = 0;

		ArrayOfCells2[ArrayIndex2] = iHeap->Alloc(GetRandomSize(0x7FFFF));

		test(ArrayOfCells2[ArrayIndex2] != NULL);

	}

	test(iHeap->Count() == 15);

	// Free all buffers in reverse order

	for(ArrayIndex=9; ArrayIndex>=0; ArrayIndex-- )

	{

		if(ArrayOfCells[ArrayIndex] != 0)

		{

			iHeap->Free(ArrayOfCells[ArrayIndex]);

			ArrayOfCells[ArrayIndex] = 0;

		}

	}

	for(ArrayIndex2=9; ArrayIndex2>=0; ArrayIndex2-- )

	{

		if(ArrayOfCells2[ArrayIndex2] != 0)

		{

			iHeap->Free(ArrayOfCells2[ArrayIndex2]);

			ArrayOfCells2[ArrayIndex2] = 0;

		}

	}

	test(iHeap->Count() == 0);

}

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

// Allocate and free multiple random sized buffers. Use              // 

// DebugFunction(EWalk) to check that all allocated cells are found. //

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

void TestRHeap::Test3(void)

{

    TUint iAllocatedArraySize = 100;

    iAllocatedArrayOfCells = new TAny*[iAllocatedArraySize];

    // allocate 100 random cells and save them in iAllocatedArrayOfCells

    for(iAllocatedArrayIndex=0; iAllocatedArrayIndex<iAllocatedArraySize; iAllocatedArrayIndex++)

    {

        iAllocatedArrayOfCells[iAllocatedArrayIndex] = 0;

        iAllocatedArrayOfCells[iAllocatedArrayIndex] = iHeap->Alloc(GetRandomSize(0xFFFF));

        test(iAllocatedArrayOfCells[iAllocatedArrayIndex] != NULL);

    }

    test(iHeap->Count() == 100);    //check that all 100 allocations have succeedeed

    // copy iAllocatedArrayOfCells => iWalkArrayOfCells

    iWalkArrayOfCells = new TAny*[iWalkArrayIndex];

    for(iWalkArrayIndex=0; iWalkArrayIndex<iWalkArraySize; iWalkArrayIndex++)

        {

            iWalkArrayOfCells[iWalkArrayIndex] = 0;

            iWalkArrayOfCells[iWalkArrayIndex] = iAllocatedArrayOfCells[iWalkArrayIndex];

            test(iWalkArrayOfCells[iWalkArrayIndex] == iAllocatedArrayOfCells[iWalkArrayIndex]);

        }

    //check that walk finds all allocated cells...

        iHeap->DebugFunction(EWalk, (TAny*)&WalkCallback, (TAny*)this);  

        TBool ret = CheckWalkArrayEmpty();

        test(ret);     // ...and iWalkArrayOfCells is emptied

	// copy iAllocatedArrayOfCells => iWalkArrayOfCells

	    iWalkArrayOfCells = new TAny*[iWalkArrayIndex];

	    for(iWalkArrayIndex=0; iWalkArrayIndex<iWalkArraySize; iWalkArrayIndex++)

	        {

	            iWalkArrayOfCells[iWalkArrayIndex] = 0;

	            iWalkArrayOfCells[iWalkArrayIndex] = iAllocatedArrayOfCells[iWalkArrayIndex];

	            test(iWalkArrayOfCells[iWalkArrayIndex] == iAllocatedArrayOfCells[iWalkArrayIndex]);

	        }

	// free 40 random cells from iWalkArrayOfCells

	TUint i;

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

	    {

        TUint RandomIndex = GetRandomIndex(99);

        iHeap->Free(iWalkArrayOfCells[RandomIndex]);

        iWalkArrayOfCells[RandomIndex] = 0;

        iAllocatedArrayOfCells[RandomIndex] = 0;

	    }

	test(iHeap->Count() == 60);

	//check that walk finds all the remaining allocated cells...

	iHeap->DebugFunction(EWalk, (TAny*)&WalkCallback, (TAny*)this);  

	ret = CheckWalkArrayEmpty();

	test(ret);     // ...and iWalkArrayOfCells is emptied

	// allocate 20 more random cells starting on the first available free cell

	iAllocatedArrayIndex = 0;

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

	    {

        while (iAllocatedArrayOfCells[iAllocatedArrayIndex] != 0)

            {

            iAllocatedArrayIndex++;

            }

        iAllocatedArrayOfCells[iAllocatedArrayIndex] = iHeap->Alloc(GetRandomSize(0xFFFF));

	    }

	test(iHeap->Count() == 80);

	// copy iAllocatedArrayOfCells => iWalkArrayOfCells

	iWalkArrayOfCells = new TAny*[iWalkArrayIndex];

	    for(iWalkArrayIndex=0; iWalkArrayIndex<iWalkArraySize; iWalkArrayIndex++)

	        {

	            iWalkArrayOfCells[iWalkArrayIndex] = 0;

	            iWalkArrayOfCells[iWalkArrayIndex] = iAllocatedArrayOfCells[iWalkArrayIndex];

	            test(iWalkArrayOfCells[iWalkArrayIndex] == iAllocatedArrayOfCells[iWalkArrayIndex]);

	        }

	//check that walk finds all the earlier and newly allocated cells...

	iHeap->DebugFunction(EWalk, (TAny*)&WalkCallback, (TAny*)this);  

	ret = CheckWalkArrayEmpty();

	test(ret);     // ...and iWalkArrayOfCells is emptied

}

void TestRHeap::CloseTests()

	{

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

		iHeap->Close();  

	}

GLDEF_C TInt E32Main(void)

	{

	test.Title();

	__KHEAP_MARK;

	TestRHeap T;

	test.Start(_L("Page Allocator Test"));

	TPtrC testHeapM=_L("TESTHEAP-MAIN");

    RHeap* iHeapM;

	iHeapM=User::ChunkHeap(&testHeapM,0x1800,0x800000); 

    TMetaData metaData;

    GetMeta(*iHeapM, metaData);

    iHeapM->Close();

    if (metaData.iDLOnly)

        {

        test.Printf(_L("Page allocator is not used, no tests to run.\n"));

        __KHEAP_MARKEND;

        test.End();

        return(0);

        }

    test.Next(_L("Init Paged allocator tests"));

    T.InitTests();

	test.Next(_L("Test Paged allocator 1"));

	T.Test1();

	test.Next(_L("Test Paged allocator 2"));

	T.Test2();

	test.Next(_L("Test Paged allocator 3"));

	T.Test3();

	T.CloseTests();

	__KHEAP_CHECK(0);

	__KHEAP_MARKEND;

	test.End();

	return (0);    

    }