// 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\system\t_ctrap.cpp

// Overview:

// Test the CCleanup, CTrapCleanup and TAutoClose classes

// API Information:

// CCleanup, CTrapCleanup, TAutoClose

// Details:

// - Test cleanup stack reallocation during cleanup.

// - Test cleanup stack modifications during the cleanup operation  

// will cause a panic.

// - Test single-level cleanup of cells, objects, items and a mix: 

// Create a CCleanup object, call a combination of methods, verify 

// the results are as expected and verify the heap has not been 

// corrupted.

// - Test multi-level cleanup of cells, objects, items and a mix: 

// Create a CCleanup object, call a combination of methods, verify 

// the results are as expected and verify the heap has not been 

// corrupted.

// - Test a variety of special case cleanup tasks. Verify that the 

// results are as expected.

// - Test CTrapCleanup cleanup of objects that either exit normally

// or leave. Also test the cleanup of multiple objects that leave.

// Verify results are as expected.

// - Test TAutoClose: create a TAutoClose object, verify that it is 

// closed when it goes out of scope, push it on the cleanup stack,

// verify cleanup results are as expected.

// - Test that the Cleanup stack can go re-entrant.

// - Ensure that the stack is properly balanced with and without

// leaving.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32panic.h>

#include <e32debug.h>

#include <e32def.h>

#include <e32def_private.h>

const TInt KInitialCount=2;

const TInt KInitialCountAll=3;

const TInt KLeaveValue=0x12345678;

const TInt KMaxAlloc=6;	

static const TInt KHeapSize = 0x2000;

enum TWhat {EPop,EPopAndDestroy,EMulti,ENull};

class CTest : public CBase

	{

public:

	void ConstructL();

private:

	TInt iData;

	};

class CTest2: public CBase 

	{

public:

	~CTest2();

	};

class CTest3: public CBase 

	{

public:

	~CTest3();

	};

class RItem

	{

public:

	RItem() : iOpen(EFalse) {}

	void Open() {iOpen=ETrue;}

	void Close() {iOpen=EFalse;}

	operator TCleanupItem() {return TCleanupItem(Cleanup,this);}

	TBool IsOpen() const {return(iOpen);}

private:

	static void Cleanup(TAny* aPtr);

private:

	TBool iOpen;

	};

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

LOCAL_D TAny* gP1;

LOCAL_D CBufFlat* gP2;

LOCAL_C void ReallocateStackL()

	{

	TInt n = 0;

	for(TInt i = 0; i < KMaxAlloc; ++i)

		{

		HBufC *p1 = HBufC::NewLC(4);   //Stack re-allocation will be performed due to the additional objects pushed

									   //into the cleanup stack

		n = p1->Length();			   //include this line to avoid warnigs for unused "p1" variable

		}

	test.Printf(_L("ReallocateStackL(): PopAndDestroy KMaxAlloc pointers\n"));

	CleanupStack::PopAndDestroy(KMaxAlloc);

	}

CTest2::~CTest2()

	{

	TInt err = KErrNoMemory;

	test.Printf(_L("~CTest2(): call ReallocateStackL()\n"));

	TRAP(err, ReallocateStackL() );

	}

CTest3::~CTest3()

	{

	RDebug::Printf("~CTest3(): Modify Cleanup stack by pushing items");

	TInt n = 0;

	for(TInt i = 0; i < KMaxAlloc; ++i)

		{

		HBufC *p1 = HBufC::NewLC(4);   //Stack re-allocation will be performed due to the additional objects pushed

									   //into the cleanup stack

		n = p1->Length();			   //include this line to avoid warnigs for unused "p1" variable

		}

	}

LOCAL_C void ModifyStack()

	{

	CTest3* ptr6 = new(ELeave)CTest3;

	CleanupStack::PushL(ptr6);

	RDebug::Printf("ModifyStack(): PopAndDestroy ptr6");

	CleanupStack::PopAndDestroy();

	}

LOCAL_C TInt PanicStackModifiedFn(TAny* aNopFn)

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	aNopFn = NULL;		//avoid warnings for unused "aNopFn" variable

	TInt err = KErrNoMemory;

	RDebug::Printf("PanicStackModifiedFn(): call TRAP(err, ModifyStack())");

	if(NULL != cleanup)

		{

		TRAP(err, ModifyStack());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return err;	

	}

LOCAL_C void PushAndCleanupL()

	{

	CTest2* ptr1 = new(ELeave)CTest2;

	CleanupStack::PushL(ptr1);

	CTest2* ptr2 = new(ELeave)CTest2;

	CleanupStack::PushL(ptr2);

	CTest2* ptr3 = new(ELeave)CTest2;

	CleanupStack::PushL(ptr3);

	test.Printf(_L("PushAndCleanupL(): PopAndDestroy ptr3, ptr2 and ptr1\n"));

	CleanupStack::PopAndDestroy(3);

	CTest2* ptr4 = new(ELeave)CTest2;

	CleanupStack::PushL(ptr4);

	CTest2* ptr5 = new(ELeave)CTest2;

	CleanupStack::PushL(ptr5);

	test.Printf(_L("PushAndCleanupL(): PopAndDestroy ptr5 and ptr4\n"));

	CleanupStack::PopAndDestroy();

	CleanupStack::PopAndDestroy();

	}

LOCAL_C void testDestructorStackReallocation()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TInt err = KErrNoMemory;

	if(NULL != cleanup)

		{

		TRAP(err, PushAndCleanupL());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	test_KErrNone(err);

	test.Printf(_L("Verify cleanup stack modification during cleanup operation causes EClnStackModified panic\n"));

	//

	//To verify the above case a new thread is created which does modify the cleanup stack during cleanup.

	//The exit reason is then checked for the appropriate value(EClnStackModified)

	//

	RThread panicThread;

	TInt r = panicThread.Create(_L("Panic EClnStackModified Thread"), PanicStackModifiedFn, KDefaultStackSize, KHeapSize, KHeapSize, NULL);

	test_KErrNone(r);

	TRequestStatus panicThreadStatus;

	panicThread.Logon(panicThreadStatus);

	//don't want just in time debugging as we trap panics

	TBool justInTime=User::JustInTime(); 

	User::SetJustInTime(EFalse); 

	panicThread.Resume();

	User::WaitForRequest(panicThreadStatus);

	test_Equal(EExitPanic, panicThread.ExitType());

	test_Equal(EClnStackModified, panicThread.ExitReason());

	User::SetJustInTime(justInTime);

	CLOSE_AND_WAIT(panicThread);

	}

LOCAL_C void createMultiL()

//

// Create an object on the cleanup list and leave

//

	{

	CBufFlat* pT=CBufFlat::NewL(8);

	User::LeaveIfNull(pT);

	CleanupStack::PushL(pT);

	__UHEAP_CHECK(3);

	User::Leave(KLeaveValue+1);

	}

LOCAL_C void createL(TWhat aWhat,TBool aLeave)

//

// Create objects and then either leave or return.

// Optionally pop them again.

//

	{

	gP1=User::AllocL(0x10);

    test.Printf(_L("createL 1"));

	CleanupStack::PushL(gP1);

    test.Printf(_L("createL 2"));

	__UHEAP_CHECK(1);

    test.Printf(_L("createL 3"));

	gP2=CBufFlat::NewL(8);

    test.Printf(_L("createL 4"));

	User::LeaveIfNull(gP2);

    test.Printf(_L("createL 5"));

	CleanupStack::PushL(gP2);

    test.Printf(_L("createL 6"));

	__UHEAP_CHECK(2);

    test.Printf(_L("createL 7"));

	if (aWhat==EPop)

		{

		test.Printf(_L("createL 8"));

		CleanupStack::Pop();

		test.Printf(_L("createL 9"));

		CleanupStack::Pop(1);

		test.Printf(_L("createL 10"));

		}

	if (aWhat==EPopAndDestroy)

		{

		test.Printf(_L("createL 11"));

		CleanupStack::PopAndDestroy();

		test.Printf(_L("createL 12"));

		CleanupStack::PopAndDestroy(1);

		test.Printf(_L("createL 13"));

		}

	if (aWhat==EMulti)

		{

		test.Printf(_L("createL 14"));

		TRAPD(r,createMultiL())

		test.Printf(_L("createL 15"));

		test(r==(KLeaveValue+1));

		test.Printf(_L("createL 16"));

		__UHEAP_CHECK(2);

		test.Printf(_L("createL 17"));

		}

	if (aLeave)

		{

		test.Printf(_L("createL 18"));

		User::Leave(KLeaveValue);

		}

    test.Printf(_L("createL 19"));

	}

LOCAL_C void createAllL(TBool aLeave)

//

// Call all functions which autmatically put objects on the cleanup list.

//

	{

	__UHEAP_CHECK(KInitialCountAll);

	TLex* pL=new(ELeave) TLex; // ::new, 1 cell

	CleanupStack::PushL(pL);								// Push

	__UHEAP_CHECK(KInitialCountAll+1);

	CTest* pT=new(ELeave) CTest; // CBase::new, 1 cell

	CleanupStack::PushL(pT);								// Push

	__UHEAP_CHECK(KInitialCountAll+2);

	pT->ConstructL(); // 1 more cell						// Push

	__UHEAP_CHECK(KInitialCountAll+3);

	User::AllocLC(0x10); // Test RHeap::AllocLC as well		// Push

	__UHEAP_CHECK(KInitialCountAll+4);

	_L("Hello").AllocLC(); // Test HBufC::NewLC() as well	// Push

	__UHEAP_CHECK(KInitialCountAll+5);

	HBufC* pH=HBufC::NewMaxLC(8);							// Push

	test(pH->Length()==8);

	__UHEAP_CHECK(KInitialCountAll+6);

	if (aLeave)

		User::Leave(KLeaveValue);

	// new behavior for TCleanupTrapHander requires Pushes to the

	// cleanup stack to be balanced by Pops

	CleanupStack::PopAndDestroy(6);

	}

LOCAL_C void testSingleLevelCellsCleanup()

//

// Test single level cells cleanup

//

	{

	test.Start(_L("Creating"));

//

	__UHEAP_MARK;

	CCleanup* pC=CCleanup::New();

	test(pC!=NULL);

//

	__UHEAP_MARK;

//

	test.Next(_L("PopAll when empty"));

	pC->NextLevel();

	pC->PopAll();

	pC->NextLevel();

	pC->PopAndDestroyAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop"));

	TAny* p=User::Alloc(0x10);

	test(p!=NULL);

	__UHEAP_CHECK(1);

	pC->NextLevel();

	pC->PushL(p);

	pC->Pop();

	__UHEAP_CHECK(1);

	User::Free(p);

	__UHEAP_CHECK(0);

	pC->PopAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop N"));

	TAny* p1=User::Alloc(0x10);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	TAny* p2=User::Alloc(0x10);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->Pop(2);

	__UHEAP_CHECK(2);

	User::Free(p1);

	User::Free(p2);

	__UHEAP_CHECK(0);

	pC->PopAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop all"));

	p1=User::Alloc(0x10);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	p2=User::Alloc(0x10);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	TAny* p3=User::Alloc(0x10);

	test(p3!=NULL);

	__UHEAP_CHECK(3);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->PushL(p3);

	pC->PopAll();

	__UHEAP_CHECK(3);

	User::Free(p1);

	User::Free(p2);

	User::Free(p3);

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop and destroy"));

	p=User::Alloc(0x10);

	test(p!=NULL);

	__UHEAP_CHECK(1);

	pC->NextLevel();

	pC->PushL(p);

	pC->PopAndDestroy();

	__UHEAP_CHECK(0);

	pC->PopAll();

//

	test.Next(_L("Push and pop and destroy N"));

	p1=User::Alloc(0x10);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	p2=User::Alloc(0x10);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->PopAndDestroy(2);

	__UHEAP_CHECK(0);

	pC->PopAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop and destroy all"));

	p1=User::Alloc(0x10);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	p2=User::Alloc(0x10);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	p3=User::Alloc(0x10);

	test(p3!=NULL);

	__UHEAP_CHECK(3);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->PushL(p3);

	pC->PopAndDestroyAll();

	__UHEAP_CHECK(0);

//

	__UHEAP_MARKEND;

//

	delete pC;

	__UHEAP_MARKEND;

//

	test.End();

	}

LOCAL_C void testSingleLevelObjCleanup()

//

// Test single level object cleanup

//

	{

	test.Start(_L("Creating"));

//

	__UHEAP_MARK;

	CCleanup* pC=CCleanup::New();

	test(pC!=NULL);

//

	__UHEAP_MARK;

//

	test.Next(_L("Push and pop"));

	CBufFlat* p=CBufFlat::NewL(8);

	test(p!=NULL);

	__UHEAP_CHECK(1);

	pC->NextLevel();

	pC->PushL(p);

	pC->Pop();

	__UHEAP_CHECK(1);

	User::Free(p);

	__UHEAP_CHECK(0);

	pC->PopAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop N"));

	CBufFlat* p1=CBufFlat::NewL(8);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	CBufFlat* p2=CBufFlat::NewL(8);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->Pop(2);

	__UHEAP_CHECK(2);

	User::Free(p1);

	User::Free(p2);

	__UHEAP_CHECK(0);

	pC->PopAll();

	__UHEAP_CHECK(0);

//

	test.Next(_L("Push and pop all"));

	p1=CBufFlat::NewL(8);

	test(p1!=NULL);

	__UHEAP_CHECK(1);

	p2=CBufFlat::NewL(8);

	test(p2!=NULL);

	__UHEAP_CHECK(2);

	CBufFlat* p3=CBufFlat::NewL(8);

	test(p3!=NULL);

	__UHEAP_CHECK(3);

	pC->NextLevel();

	pC->PushL(p1);

	pC->PushL(p2);

	pC->PushL(p3);

	pC->PopAll();

	__UHEAP_CHECK(3);

	User::Free(p1);

	User::Free(p2);

	User::Free(p3);

	__UHEAP_CHECK(0);