// 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_heapdb.cpp
// Tests the _DEBUG build dependent aspects of RHeap
// Overview:
// Tests debug build dependent aspects of RHeap.  
// API Information:
// RHeap.
// Details:
// Test1:
// - Allocate a variety of user heap objects and verify the nesting level, allocation count, 
// allocation level and length are correct. Also check for heap corruption.
// Test 2:
// - Some assorted indirect calls to alloc, and verify the nesting level, allocation count, 
// allocation level and length are correct. Also check for heap corruption.
// Test3:
// - Allocate a variety of objects and verify that the UHEAP_CHECKALL count is correct.
// - Verify the nesting of UHEAP_MARK and UHEAP_MARKEND macros.
// - Check the validity of the current thread's default heap.
// Test4:
// - Allocate memory for different heaps, check the total number of allocated cells
// for different heaps and for the current nested level is as expected.
// Test5:
// - Simulate heap allocation failures, allocate the memory from user and 
// kernel heap and check results are as expected.
// Platforms/Drives/Compatibility:
// All
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

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

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

#if defined(_DEBUG)

RHeap::SHeapCellInfo CellInfo[4];

class RTestHeap : public RHeap
	{
public:
	void AttachInfo(SHeapCellInfo* aInfo)
		{iTestData = aInfo;}
	};

void AttachToHeap(RHeap* aHeap, TInt aInfo)
	{
	if (!aHeap)
		aHeap = (RHeap*)&User::Allocator();
	((RTestHeap*)aHeap)->AttachInfo(CellInfo + aInfo);
	}

void TestCellInfo(TInt aInfo, TInt aNest, TInt aAllocCount, TInt aLevelAlloc, TInt aSize, TAny* aAddr)
	{
	RHeap::SHeapCellInfo& ci = CellInfo[aInfo];
	RHeap::SDebugCell& cell = *ci.iStranded;
	test(cell.nestingLevel == aNest);
	test(cell.allocCount == aAllocCount);
	test(ci.iLevelAlloc == aLevelAlloc);
	test(cell.len == aSize + RHeap::EAllocCellSize);
	test((&cell+1) == aAddr);
	}

const TInt KMaxFailureRate=100;
const TInt KThreadMemError=-50;
const TInt KCellSize=(sizeof(RHeap::SCell)); // Size of free cell header	
const TInt KHeadSize=(sizeof(RHeap::SDebugCell)); // Size of allocated cell header with space for heaven info

LOCAL_D TInt heapCount=1;
LOCAL_D RSemaphore threadSemaphore;
LOCAL_D TBool array1[KMaxFailureRate+1];
LOCAL_D	TBool array2[KMaxFailureRate+1];

LOCAL_C TInt ThreadEntryPoint(TAny*)
	{
	threadSemaphore.Wait();
	if (User::Alloc(4)==NULL)
		return(KThreadMemError);
	else
		return(KErrNone);
	} 

class TestRHeapDebug
	{
public:
	void Test1(void);
	void Test2(void);
	void Test3(void);
	void Test4(void);
	void Test5(void);
	};

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

void TestRHeapDebug::Test1(void)
	{

	TAny* p;

	///////////////////////
	// Test heaven cell is found for each method of allocating memory
	////////////////////////

	// new(TInt aSize)
	__UHEAP_MARK;
	__UHEAP_CHECKALL(0);
	__UHEAP_CHECK(0);
	p=new TUint; 
	__UHEAP_CHECKALL(1);
	__UHEAP_CHECK(1);
	__UHEAP_MARKEND;
	__UHEAP_CHECK(0);
	__UHEAP_CHECKALL(1);
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// new(TInt aSize,TInt anExtraSize)
	__UHEAP_MARK;
	p=new(4) TUint; 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// 	new(TInt aSize,TLeave)
	__UHEAP_MARK;
	p=new(ELeave) TUint; 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// Alloc
	__UHEAP_MARK;
	p=User::Alloc(32); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// AllocL
	__UHEAP_MARK;
	p=User::AllocL(32);
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// ReAlloc with Null parameter
	__UHEAP_MARK;
	p=User::ReAlloc(NULL, 32); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// ReAllocL with Null parameter
	__UHEAP_MARK;
	p=User::ReAllocL(NULL, 32); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);

	// ReAlloc with non Null parameter
	__UHEAP_MARK;
	p=User::Alloc(128);	   
	p=User::ReAlloc(p, 4); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);
					
	// ReAlloc with non Null parameter such that cell is moved in memory
	__UHEAP_MARK;
	p=User::Alloc(128);	   
	TAny* temp=User::Alloc(128);
	p=User::ReAlloc(p, 526);   
	User::Free(temp);
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 3, 1, User::AllocLen(p), p);
	User::Free(p);

	// ReAllocL with non Null parameter
	__UHEAP_MARK;
	p=User::Alloc(32);	   
	p=User::ReAllocL(p, 128); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p), p);
	User::Free(p);
	}


void TestRHeapDebug::Test2(void)
	{ 
	// Some assorted indirect calls to alloc

	__UHEAP_MARK;
	CBufFlat* pBuf=CBufFlat::NewL(10); 
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(pBuf), pBuf);
	delete pBuf;

	__UHEAP_MARK;
	HBufC8* pHBufC=HBufC8::New(10);	
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(pHBufC), pHBufC);
	delete pHBufC;

// can also create a HBufC8 from a descriptor by using TDesC::Alloc
	}


void TestRHeapDebug::Test3(void)
	{ 

	//  Check num of cells detected is correct and CHECKTOTALNUM is ok
	// NOTE: CHECKTOTALNUM counts the TOTAL number of allocations in the heap regardless of
	// any MARKSTARTs
	// NOTE: the alloc count commences from the FIRST occurrence of a MARKSTART, so if one is nested
	// in another the alloc count will only start from the second MARKSTART if it applies to a 
	// different heap.
	__UHEAP_MARK;
	__UHEAP_CHECKALL(0);
	TAny* p1= new TUint; 
	__UHEAP_CHECKALL(1);
	TAny* p2= new(20) TUint;
	__UHEAP_CHECKALL(2);
	TAny* p3= User::Alloc(15); 
	__UHEAP_CHECKALL(3);
	__UHEAP_MARK;
	__UHEAP_CHECK(0);
	TAny* p4=User::Alloc(1); 
	TAny* p5 =new TUint; 
	__UHEAP_CHECK(2);
	__UHEAP_CHECKALL(5);
	__UHEAP_MARKEND;
	TestCellInfo(0, 2, 4, 2, User::AllocLen(p4), p4);
	__UHEAP_CHECKALL(5);
	__UHEAP_CHECK(3);
	__UHEAP_MARKENDC(3);
	User::Free(p1);
	User::Free(p2);
	User::Free(p3);
	User::Free(p4);
	User::Free(p5);

	// Check some nesting out
	p1=new TUint;
	__UHEAP_MARK;
	p2=new TUint; 
	__UHEAP_MARK;
	p3=new TUint; 
	__UHEAP_MARK;
	p4=new TUint; 
	__UHEAP_MARKEND;
	TestCellInfo(0, 3, 3, 1, User::AllocLen(p4), p4);
	__UHEAP_MARKEND;
	TestCellInfo(0, 2, 2, 1, User::AllocLen(p3), p3);
	__UHEAP_MARKEND;
	TestCellInfo(0, 1, 1, 1, User::AllocLen(p2), p2);
	User::Free(p1);
	User::Free(p2);
	User::Free(p3);
	User::Free(p4);
	User::Check();
	}

void TestRHeapDebug::Test4(void)
	{
	// Test with different heaps
	TAny* p1=new TUint;
	__UHEAP_MARK;	// Default start
	__UHEAP_CHECKALL(1);
	__UHEAP_CHECK(0);
	TAny* p2=new TUint;	  
	RHeap* pHeap1=allocHeap(1000); 
	AttachToHeap(pHeap1,1);
	__RHEAP_MARK(pHeap1); // Heap1 start
	__RHEAP_CHECKALL(pHeap1,0);
	__RHEAP_CHECK(pHeap1,0);
	TAny* p3=pHeap1->Alloc(4); 
	__RHEAP_CHECKALL(pHeap1,1);
	__RHEAP_CHECK(pHeap1,1);
	__RHEAP_CHECKALL(pHeap1,1);
	__UHEAP_CHECKALL(3);
	RHeap* pHeap2=allocHeap(1000);
	AttachToHeap(pHeap2,2);
	RHeap* pHeap3=allocHeap(1000);
	AttachToHeap(pHeap3,3);
	__UHEAP_CHECKALL(5);
	__RHEAP_MARK(pHeap2); // Heap2 start
	__RHEAP_MARK(pHeap3); // Heap3 start
	TAny* p4=pHeap2->Alloc(8); 
	TAny* p5=pHeap2->Alloc(37);
	TAny* p6=pHeap3->Alloc(32);	
	TAny* p7=pHeap1->Alloc(43);	
	__UHEAP_CHECKALL(5);
	__RHEAP_CHECKALL(pHeap1,2);
	__RHEAP_CHECKALL(pHeap2,2);
	__RHEAP_CHECKALL(pHeap3,1);
	__RHEAP_MARKEND(pHeap3); // Heap3 end
	TestCellInfo(3, 1, 1, 1, pHeap3->AllocLen(p6), p6);
	__RHEAP_MARKEND(pHeap2); // Heap2 end
	TestCellInfo(2, 1, 1, 2, pHeap2->AllocLen(p4), p4);
	pHeap1->Free(p3);
	__RHEAP_MARKEND(pHeap1); // Heap1 end
	TestCellInfo(1, 1, 2, 1, pHeap1->AllocLen(p7), p7);
	User::Free(p1);
	User::Free(p2);
	pHeap2->Free(p4);
	pHeap2->Free(p5);
	pHeap3->Free(p6);
	pHeap1->Free(p7);
	__UHEAP_CHECKALL(3);   
	pHeap2->Close();
	pHeap3->Close();
	__UHEAP_MARKEND;
	pHeap1->Close();
	__UHEAP_CHECKALL(0);
	}

void TestRHeapDebug::Test5()
// Check the alloc failure macros
	{
	TAny *p, *p1;
	RHeap* pHeap=allocHeap(1000);

	// DETERMINISTIC FAILURE
	__UHEAP_RESET;
	__UHEAP_FAILNEXT(1);
	test(User::Alloc(1)==NULL);
	p=User::Alloc(1);
	test(p!=NULL);
	User::FreeZ(p);
	__UHEAP_RESET;

	__RHEAP_RESET(pHeap);
	__RHEAP_FAILNEXT(pHeap,1);
	test(pHeap->Alloc(1)==NULL);
	p=pHeap->Alloc(1);
	test(p!=NULL);
	pHeap->FreeZ(p);
   	__RHEAP_RESET(pHeap);

	__KHEAP_RESET;
	__KHEAP_FAILNEXT(1);
	RSemaphore semaphore;
	test(semaphore.CreateLocal(1)==KErrNoMemory); // allocated from the kernel heap
	test(semaphore.CreateLocal(1)==KErrNone);
	semaphore.Close();
	__KHEAP_RESET;

	__UHEAP_SETFAIL(RHeap::EDeterministic,0);
	test(User::Alloc(1)==NULL);
	__UHEAP_RESET;

	__RHEAP_SETFAIL(pHeap,RHeap::EDeterministic,0);
	test(pHeap->Alloc(1)==NULL);
	__RHEAP_RESET(pHeap);

	__KHEAP_SETFAIL(RHeap::EDeterministic,0);
	test(semaphore.CreateLocal(1)==KErrNoMemory);
	__KHEAP_RESET;

	TInt determinism;
	for(determinism=1; determinism<=KMaxFailureRate; determinism++)
		{
		__UHEAP_SETFAIL(RHeap::EDeterministic,determinism);
		__RHEAP_SETFAIL(pHeap,RHeap::EDeterministic,determinism);
		for(TInt ii=1; ii<=determinism; ii++)
			{
			p=User::Alloc(1);
			p1=pHeap->Alloc(1);
			if(ii%determinism==0)
				{
				test(p==NULL);
				test(p1==NULL);
				}
			else
				{
				test(p!=NULL);
				test(p1!=NULL);
				pHeap->Free(p1); 
				User::Free(p);
				}
			}
		}
	__UHEAP_RESET;
	__RHEAP_RESET(pHeap);

	// Test SetKernelAllocFail
	// its not possible to test SetKernelAllocFail as above as it is not possible to control the
	// number of calls to Alloc for the dernel heap - but the following will definitely fail:
	__KHEAP_SETFAIL(RHeap::EDeterministic,1);
	RSemaphore r; 
	test(r.CreateLocal(1)==KErrNoMemory); // allocated from the kernel heap
	__KHEAP_SETFAIL(RHeap::EDeterministic,50);
	test(r.CreateLocal(1)==KErrNone);
	r.Close();
	__KHEAP_RESET;

	// RANDOM TESTS
	TInt numOccurences1, numOccurences2;

	__UHEAP_SETFAIL(RHeap::ERandom,1);
	test(User::Alloc(1)==NULL);
	__UHEAP_RESET;

	__RHEAP_SETFAIL(pHeap,RHeap::ERandom,1);
	test(pHeap->Alloc(1)==NULL);
	__RHEAP_RESET(pHeap);

//	__KHEAP_SETFAIL(RHeap::ERandom,1);
//	test(semaphore.CreateLocal(1)==KErrNoMemory);
//	__KHEAP_RESET;

	__UHEAP_SETFAIL(RHeap::ETrueRandom,1);
	test(User::Alloc(1)==NULL);
	__UHEAP_RESET;

	__RHEAP_SETFAIL(pHeap,RHeap::ETrueRandom,1);
	test(pHeap->Alloc(1)==NULL);
	__RHEAP_RESET(pHeap);

//	__KHEAP_SETFAIL(RHeap::ETrueRandom,1);
//	test(semaphore.CreateLocal(1)==KErrNoMemory);
//	__KHEAP_RESET;

	for(determinism=1; determinism<=KMaxFailureRate; determinism++)
		{
		__UHEAP_SETFAIL(RHeap::ERandom,determinism);
		__RHEAP_SETFAIL(pHeap,RHeap::ERandom,determinism);
        TInt ii;
		for(ii=1; ii<=determinism; ii++)
			{
			p=User::Alloc(1);
			p1=pHeap->Alloc(1);
			array1[ii]=(p==NULL);
			array2[ii]=(p==NULL);
			if(p)
				User::Free(p);
			if(p1)
				pHeap->Free(p1);
			}
		numOccurences1=0;
		numOccurences2=0;
		for(ii=1; ii<=determinism; ii++)
			{
			if(array1[ii])
				numOccurences1++;					
			if(array2[ii])
				numOccurences2++;
			}
		test(numOccurences1==1);
		test(numOccurences2==1);
		}
	__UHEAP_RESET;
	__RHEAP_RESET(pHeap);		

	__UHEAP_SETFAIL(RHeap::ERandom,5);
	TInt ii;
	for(ii=1; ii<=50; ii++)
		{
		p=User::Alloc(1);
		array1[ii]=(p==NULL);
		if(p)	
			User::Free(p);
		}
	numOccurences1=0;
	numOccurences2=0;
	for(ii=1; ii<=50; ii++)
		{
		if(array1[ii])
			{
			numOccurences1++;
			numOccurences2++;
			}
		if(ii%5==0)
			{
			test(numOccurences1==1);
			numOccurences1=0;
			}
		}
	test(numOccurences2==50/5);	
	
	// Cannot really test random failure of the kernel heap accurately

	pHeap->Close();
	//client.Disconnect();

	// Test failing the heap of a child thread
	// 1st test that it allocates normally
	TRequestStatus stat;
	RThread thread;
	test(threadSemaphore.CreateLocal(0)==KErrNone);
	test(thread.Create(_L("Thread"),ThreadEntryPoint,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	threadSemaphore.Signal();
	User::WaitForRequest(stat);
	test(thread.ExitReason()==KErrNone);
	thread.Close();
#if defined(CAN_TEST_THREADS)
	// Now make the thread's heap fail
	test(thread.Create(_L("Thread"),ThreadEntryPoint,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	TH_FAILNEXT(thread.Handle());
	threadSemaphore.Signal();
	User::WaitForRequest(stat);
	test(thread.ExitReason()==KThreadMemError);
	thread.Close();
	threadSemaphore.Close();
#endif
	}	

GLDEF_C TInt E32Main(void)
    {

	test.Title();
	AttachToHeap(NULL,0);
	test.Start(_L("Test1"));
	TestRHeapDebug T;
	T.Test1();	 
	test.Next(_L("Test2"));
	T.Test2();
	test.Next(_L("Test3"));
	T.Test3();
	test.Next(_L("Test4"));
	T.Test4();
	test.Next(_L("Test5"));
	T.Test5();
	test.End();
	return(0);
    }
#else
GLDEF_C TInt E32Main()
//
// Test unavailable in release build.
//
    {

	test.Title();	
	test.Start(_L("No tests for release builds"));
	test.End();
	return(0);
    }
#endif