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

// Tests CONSTRUCTORS_MAY_LEAVE and OR_LEAVE macros

// 

//

#include <e32base.h>

#include <e32test.h>

#include <e32def.h>

#include <e32cmn.h>

#include <f32file.h>

#include "emisc.h"

#include "euserhl.h"

RTest test(_L("RAII-based automatic resource management tests"));

TInt TExtendedTestL();

class CTracker : public CBase

	{

  public:

	CONSTRUCTORS_MAY_LEAVE

	enum TConstructionMode { ENonleavingConstructor, EConstructorLeaves};

	static CTracker* NewL()

		{

		return new(ELeave) CTracker;

		}

	static CTracker* NewL(TConstructionMode aMode)

		{

		return new(ELeave) CTracker(aMode);

		}

	CTracker()

		: iData(new(ELeave) TInt)

		{

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

		*iData = 3;

		}

	explicit CTracker(TConstructionMode aMode)

		: iData(new(ELeave) TInt(aMode))

		{

		if (aMode == EConstructorLeaves)

			{

			test.Printf(_L("CTracker(EConstructorLeaves): Now leaving with User::Leave(KErrGeneral)\n"));

			User::Leave(KErrGeneral);

			}

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

		}

	CTracker(CTracker& aTracker)

		: iData(aTracker.iData.Unmanage())

		{

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

		}

	CTracker& operator=(CTracker& aTracker)

		{

		iData = aTracker.iData.Unmanage();

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

		return *this;

		}

	virtual ~CTracker()

		{

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

		}

	virtual void MemFunc()

		{

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

		}

	virtual TInt Value()

		{

		return *iData;

		}

	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:

	LManagedPtr<TInt> iData;

	};

TBool trackerDestroyed = EFalse;

class TCTrackerDestroy

	{

public:

	static void Cleanup(CTracker* aPtr)

		{

		test.Printf(_L("TCTrackerDestroy::Cleanup\n"));

		delete aPtr;

		trackerDestroyed = ETrue;

		}

	};

class CDerivedTracker: public CTracker

	{

  public:

	CONSTRUCTORS_MAY_LEAVE

	static CDerivedTracker* NewL()

		{

		return new(ELeave) CDerivedTracker;

		}

	static CDerivedTracker* NewL(CTracker::TConstructionMode aMode)

		{

		return new(ELeave) CDerivedTracker(aMode);

		}

	CDerivedTracker()

		: iRealData(new(ELeave) TReal64)

		{

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

		*iRealData = 5.5;

		}

	CDerivedTracker(CTracker::TConstructionMode aMode)

		{

		if (aMode == EConstructorLeaves)

			{

			test.Printf(_L("CDerivedTracker(EConstructorLeaves): Now leaving with User::Leave(KErrGeneral)\n"));

			User::Leave(KErrGeneral);

			}

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

		}

	CDerivedTracker(CDerivedTracker& aDerivedTracker)

		: CTracker(aDerivedTracker),

		  iRealData(aDerivedTracker.iRealData.Unmanage())

		{

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

		}

	CDerivedTracker& operator=(CDerivedTracker& aDerivedTracker)

		{

		CTracker::operator=(aDerivedTracker);

		iRealData = aDerivedTracker.iRealData.Unmanage();

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

		return *this;

		}

	virtual ~CDerivedTracker()

		{

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

		}

	virtual void MemFunc()

		{

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

		}

	static void StaticMemberRef(const CDerivedTracker& aTracker)

		{

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

		}

	static void StaticMemberPtr(CDerivedTracker* aTracker)

		{

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

		}

  private:

	LManagedPtr<TReal64> iRealData;

	};

namespace Log

{

class RLogger

	{

  public:

	RLogger()

		: iData(NULL)

		{

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

		}

	RLogger(TInt* aData)

		: iData(aData)

		{

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

		}

	RLogger(TInt aValue)

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

		{

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

		}

	void OpenL(TInt aValue)

		{

		iData = new(ELeave) TInt(aValue);

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

		}

	RLogger(const RLogger& aLogger)

		: iData(aLogger.iData)

		{

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

		}

	RLogger& operator=(const RLogger& aLogger)

		{

		iData = aLogger.iData;

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

		return *this;

		}

	~RLogger()

		{

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

		}

	void Close()

		{

		test.Printf(_L("  RLogger::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("  RLogger::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("  RLogger::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("  RLogger::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("  RLogger::MemFunc - %x %x\n"), this, iData);

		}

	static void StaticMemberRef(const RLogger& aTracker)

		{

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

		}

	static void StaticMemberPtr(RLogger* aTracker)

		{

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

		}

	static void Cleanup(TAny* aRlogger)

		{

		static_cast<RLogger*>(aRlogger)->Close();

		}

	TInt* GetData() const

		{

		return iData;

		}

  protected:

	TInt* iData;

	};

DEFINE_CLEANUP_FUNCTION(RLogger, Release);

class ROtherLogger

	{

  public:

	ROtherLogger()

		: iData(NULL)

		{

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

		}

	ROtherLogger(TInt* aData)

		: iData(aData)

		{

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

		}

	ROtherLogger(TInt aValue)

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

		{

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

		}

	void OpenL(TInt aValue)

		{

		iData = new(ELeave) TInt(aValue);

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

		}

	ROtherLogger(const ROtherLogger& aLogger)

		: iData(aLogger.iData)

		{

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

		}

	ROtherLogger& operator=(const ROtherLogger& aLogger)

		{

		iData = aLogger.iData;

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

		return *this;

		}

	~ROtherLogger()

		{

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

		}

	void Close()

		{

		test.Printf(_L("  ROtherLogger::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("  ROtherLogger::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("  ROtherLogger::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("  ROtherLogger::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("  ROtherLogger::MemFunc - %x %x\n"), this, iData);

		}

	static void StaticMemberRef(const ROtherLogger& aTracker)

		{

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

		}

	static void StaticMemberPtr(ROtherLogger* aTracker)

		{

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

		}

	static void Cleanup(TAny* aRlogger)

		{

		static_cast<ROtherLogger*>(aRlogger)->Close();

		}

	operator RLogger() const

		{

		test.Printf(_L("  ROtherLogger::operator RLogger() - %x\n"), this);

		return RLogger(iData);

		}

	ROtherLogger& operator=(const RLogger& aLogger)

		{

		iData = aLogger.GetData();

		test.Printf(_L("  ROtherLogger::operator=(const RLogger&) - %x copy from %x ptr %x\n"), this, &aLogger, aLogger.GetData());

		return *this;

		}

  protected:

	TInt* iData;

	};

} // namespace Log

class RPair

	{

  public:

	RPair(const TInt& x, const TInt& y)

		: iX(x), iY(y)

		{

		test.Printf(_L("  RPair::RPair(const TInt& x, const TInt& y) %x %d %d\n"), iX, iY);

		}

	RPair(TInt& x, TInt& y)

		: iX(x), iY(y)

		{

		test.Printf(_L("  RPair::RPair(TInt& x, TInt& y) %x %d %d\n"), iX, iY);

		}

	void Close()

		{

		test.Printf(_L("  RPair::Close() %x %d %d\n"), iX, iY);

		}

  private:

	TInt iX;

	TInt iY;

	};

using Log::RLogger;

using Log::ROtherLogger;

class TLogger

	{

  public:

	TLogger()

		{

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

		}

	TLogger(const TLogger&)

		{

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

		}

	TLogger& operator=(const TLogger&)

		{

		test.Printf(_L("  TLogger::operator=(const TLogger& aLogger) - %x (copy)\n"), this);

		return *this;

		}

	~TLogger()

		{

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

		}

	void Test()