diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/genericusabilitylib/test/src/t_emanagedLcleanup.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/lowlevellibsandfws/genericusabilitylib/test/src/t_emanagedLcleanup.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,427 @@
+// 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;
+	}
+
+
+