// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Overview:

// Test methods of the LManagedX and LCleanedupX classes.

// 

// 

//

#include "emanaged.h"

#include <e32base.h>

#include <e32test.h>

#include <e32def.h>

#include <e32cmn.h>

extern RTest test;

template<TInt Value>

class CTracker : public CBase

	{

public:

	enum TConstructionMode { ENonleavingConstructor, EConstructorLeaves};

	static CTracker* NewL()

		{

		CTracker* ptr = new(ELeave) CTracker;

		ptr->ConstructL();

		return ptr;

		}

	CTracker():iData(NULL)

		{

		test.Printf(_L("  CTracker - %x\n"), this);

		}

	void ConstructL()

		{

		test.Printf(_L("  CTracker::ConstructL - %x\n"), this);

		iData = new(ELeave) TInt(Value);

		}

public:

	virtual ~CTracker()

		{

		test.Printf(_L("  ~CTracker - %x\n"), this);

		if(iData)

			{

			delete iData;	

			}

		}

	virtual void MemFunc()

		{

		test.Printf(_L("  CTracker::MemFunc - %x\n"), this);

		}

	static void StaticMemberRef(const CTracker& aTracker)

		{

		test.Printf(_L("  CTracker::StaticMemberRef - %x\n"), &aTracker);

		}

	static void StaticMemberPtr(CTracker* aTracker)

		{

		test.Printf(_L("  CTracker::StaticMemberPtr - %x\n"), aTracker);

		}

  private:

	TInt* iData;

	};

namespace Log

{

class RLoggerNew

	{

  public:

	RLoggerNew()

		: iData(NULL)

		{

		test.Printf(_L("  RLoggerNew - %x\n"), this);

		}

	RLoggerNew(TInt* aData)

		: iData(aData)

		{

		test.Printf(_L("  RLoggerNew - %x ptr %x -> val %d\n"), this, aData, *iData);

		}

	RLoggerNew(TInt aValue)

		: iData(new(ELeave) TInt(aValue))

		{

		test.Printf(_L("  RLoggerNew - %x value %d\n"), this, *iData);

		}

	void OpenL(TInt aValue)

		{

		iData = new(ELeave) TInt(aValue);

		test.Printf(_L("  RLoggerNew::OpenL(TInt aValue) - %x value %d\n"), this, *iData);

		}

	RLoggerNew(const RLoggerNew& aLogger)

		: iData(aLogger.iData)

		{

		test.Printf(_L("  RLoggerNew::RLoggerNew(const RLoggerNew&) - %x (copy)\n"), this);

		}

	RLoggerNew& operator=(const RLoggerNew& aLogger)

		{

		iData = aLogger.iData;

		test.Printf(_L("  RLoggerNew::operator=(const RLoggerNew&) - %x copy from %x val %d\n"), this, &aLogger, *aLogger.iData);

		return *this;

		}

	~RLoggerNew()

		{

		test.Printf(_L("  ~RLoggerNew - %x\n"), this);

		}

	void Close()

		{

		test.Printf(_L("  RLoggerNew::Close - %x\n"), this);

		// Open or non-NULL initializing constructor not called or

		// cleanup function already called

		__ASSERT_ALWAYS(iData != NULL, test.Panic(_L("NULL pointer")));

		delete iData;

		iData = NULL;

		}

	void Release()

		{

		test.Printf(_L("  RLoggerNew::Release - %x\n"), this);

		// Open or non-NULL initializing constructor not called or

		// cleanup function already called

		__ASSERT_ALWAYS(iData != NULL, test.Panic(_L("NULL pointer")));

		delete iData;

		iData = NULL;

		}

	void Destroy()

		{

		test.Printf(_L("  RLoggerNew::Destroy - %x\n"), this);

		// Open or non-NULL initializing constructor not called or

		// cleanup function already called

		__ASSERT_ALWAYS(iData != NULL, test.Panic(_L("NULL pointer")));

		delete iData;

		iData = NULL;

		}

	void Free()

		{

		test.Printf(_L("  RLoggerNew::Free - %x\n"), this);

		// Open or non-NULL initializing constructor not called or

		// cleanup function already called

		__ASSERT_ALWAYS(iData != NULL, test.Panic(_L("NULL pointer")));

		delete iData;

		iData = NULL;

		}

	void MemFunc()

		{

		test.Printf(_L("  RLoggerNew::MemFunc - %x %x\n"), this, iData);

		}

	static void StaticMemberRef(const RLoggerNew& aTracker)

		{

		test.Printf(_L("  RLoggerNew::StaticMemberRef - %x\n"), &aTracker);

		}

	static void StaticMemberPtr(RLoggerNew* aTracker)

		{

		test.Printf(_L("  RLoggerNew::StaticMemberPtr - %x\n"), aTracker);

		}

	static void Cleanup(TAny* aRLoggerNew)

		{

		static_cast<RLoggerNew*>(aRLoggerNew)->Close();

		}

	TInt* GetData() const

		{

		return iData;

		}

  protected:

	TInt* iData;

	};

DEFINE_CLEANUP_FUNCTION(RLoggerNew, Release);

}//namespace Log

using Log::RLoggerNew;

//------------------------------------------	

//LCleanedupPtr tests here

//------------------

template<TInt Value>

void TestLCleanedupPtrGenerateL()

	{

	__UHEAP_MARK;

		{

		LCleanedupPtr<CTracker<Value> > tracker(CTracker<Value>::NewL());

 		tracker->MemFunc();

		}

	__UHEAP_MARKEND;

	test.Printf(_L("__UHEAP_MARKEND - OK\n"));

	}

template<TInt Value>

void GenerateLCleanedupPtrTestL()

	{

	TestLCleanedupPtrGenerateL<Value>();

	GenerateLCleanedupPtrTestL<Value - 1>();

	}

template<>

void GenerateLCleanedupPtrTestL<0>()

	{

	TestLCleanedupPtrGenerateL<0>();

	}

//-------------------------------------------

//LCleanedupArray tests here

//-----------------

template<TInt Value>

void TestLCleanedupArrayGenerateL()

	{

	__UHEAP_MARK;

		{

		LCleanedupArray<CTracker<Value> > tracker(new(ELeave) CTracker<Value>[Value]);

 		}

	__UHEAP_MARKEND;

	test.Printf(_L("__UHEAP_MARKEND - OK\n"));

	}

template<TInt Value>

void GenerateLCleanedupArrayTestL()

	{

	TestLCleanedupArrayGenerateL<Value>();

	GenerateLCleanedupArrayTestL<Value - 1>();

	}

template<>

void GenerateLCleanedupArrayTestL<0>()

	{

	TestLCleanedupArrayGenerateL<0>();

	}

//-----------------------------------

//LCleanedupGuard Tests Here

//---------------------------

template<TInt Value>

void TestLCleanedupGuardTestGenerateL()

	{

	__UHEAP_MARK;

		{

		RLoggerNew logger(Value);

		LCleanedupGuard cleanGuard(RLoggerNew::Cleanup, &logger);

 		}

	__UHEAP_MARKEND;

	test.Printf(_L("__UHEAP_MARKEND - OK\n"));

	}

template<TInt Value>

void GenerateLCleanedupGuardTestL()

	{

	TestLCleanedupGuardTestGenerateL<Value>();

	GenerateLCleanedupGuardTestL<Value - 1>();

	}

template<>

void GenerateLCleanedupGuardTestL<0>()

	{

	TestLCleanedupGuardTestGenerateL<0>();

	}

//----------------------------------------

//LCleanedupHandle Tests Here

//-----------------------

template<TInt Value>

void TestLCleanedupHandleGenerateL()

	{

	__UHEAP_MARK;

		{

		LCleanedupHandle<RLoggerNew> logger(Value);

		}

	__UHEAP_MARKEND;

	test.Printf(_L("__UHEAP_MARKEND - OK\n"));

	}

template<TInt Value>

void GenerateLCleanedupHandleTestL()

	{

	TestLCleanedupHandleGenerateL<Value>();

	GenerateLCleanedupHandleTestL<Value - 1>();

	}

template<>

void GenerateLCleanedupHandleTestL<0>()

	{

	TestLCleanedupHandleGenerateL<0>();

	}

//------------------------------------------

//LCleanedupRef Tests Here

//-------------------------

template<TInt Value>

void TestLCleanedupRefGenerateL()

	{

	__UHEAP_MARK;

		{

		RLoggerNew logger;

		logger.OpenL(Value);

		LCleanedupRef<RLoggerNew> rlog(logger);

		rlog.ReleaseResource();		

		}

	__UHEAP_MARKEND;

	test.Printf(_L("__UHEAP_MARKEND - OK\n"));

	}

template<TInt Value>

void GenerateLCleanedupRefTestL()

	{

	TestLCleanedupRefGenerateL<Value>();

	GenerateLCleanedupRefTestL<Value - 1>();

	}

template<>

void GenerateLCleanedupRefTestL<0>()

	{

	TestLCleanedupRefGenerateL<0>();

	}

/**

@SYMTestCaseID 			BASESRVCS-EUSERHL-UT-4071

@SYMTestCaseDesc 		Tests multiple defined symbols of ManagedPopCleanupStackItem method 

						and also does stress testing of the template classes.

						Tests All the different Templated Class such as

						LCleanedupRef,LCleanedupGuard,LCleanedupHandle,LCleanedupArray and LCleanedupPtr

						for performance as well by explicit instantiation of the templated class using recurrsion.		

@SYMTestPriority 		High

@SYMTestActions 		Creates multiple instances of LCleanedupArray,LCleanedupPtr and LCleanedupRef etc

						Verifies that the objects are automatically cleaned up when they go

						out of scope

@SYMTestExpectedResults All memory allocated for the LXXX objects

						is automatically freed when they go out of scope and there are no 

						errors on multiple definition of ManagedPopCleanupStackItem is produced.

@SYMREQ					DEF137572

*/

TInt TExtendedTestL()

	{

	//------------

	TRAPD(status, GenerateLCleanedupPtrTestL<64>());

	if (status != KErrNone)

		{

		test.Printf(_L("LCleanedupPtr; leave code: %d\n"), status);

		}

	TRAPD(status1,GenerateLCleanedupArrayTestL<64>());

	if(status1 !=KErrNone)

		{

		test.Printf(_L("LCleanedupArray completed;leave code:%d\n"),status1);			

		}

	TRAPD(status2,GenerateLCleanedupGuardTestL<64>());

	if(status2 !=KErrNone)

		{

		test.Printf(_L("LCleanedupGuard completed;leave code:%d\n"),status2);			

		}

	TRAPD(status3,GenerateLCleanedupHandleTestL<64>());

	if(status3 !=KErrNone)

		{

		test.Printf(_L("LCleanedupHandle completed;leave code:%d\n"),status3);			

		}

	TRAPD(status4,GenerateLCleanedupRefTestL<64>());

	if(status4 !=KErrNone)

		{

		test.Printf(_L("LCleanedupRef completed;leave code:%d\n"),status4);			

		}

	return status;

	}