/*

* 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: 

* TUndo.cpp test file for UndoSystem classes

*

*/

#include <e32test.h>

#include "UndoSystem.h"

#include "UndoSystemImpl.h"

#include "EditorUndo.h"

#include "EditorPlainTextUndo.h"

#include <txtetext.h>

#include <conpics.h>

#include <s32mem.h>

#include <s32ucmp.h>

#include "TGraphicsContext.h"

#include "form_and_etext_editor.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <txtclipboard.h>

#include "txtfmlyr_internal.h"

#endif

#define UNUSED_VAR(a) a = a

using namespace UndoSystem;

namespace

{

}

//

//

//  logger

//

//

class CLogger : public CBase

	{

public:

	virtual void Output(const TDesC& aText) = 0;

	void Output(TInt a)

		{

		TBuf<16> num(_L("<"));

		num.AppendNum(a);

		num.Append(_L(">"));

		Output(num);

		}

	};

namespace

{

CLogger& operator<<(CLogger& aLog, const TDesC& aText)

	{

	aLog.Output(aText);

	return aLog;

	}

CLogger& operator<<(CLogger& aLog, TInt aVal)

	{

	aLog.Output(aVal);

	return aLog;

	}

}

class CCheckingLogger : public CLogger

	{

	const TDesC*	iCheck;

	TInt			iPos;

	TBool			iFailed;

public:

	void SetCheckString(const TDesC& aCheck) { iCheck = &aCheck; iPos = 0; iFailed = EFalse; }

	TBool Failed() { return iFailed; }

	TBool Passed() { return !iFailed && iCheck && iCheck->Length() == iPos; }

	void Output(const TDesC& aText)

		{

		if (!iCheck || iFailed)

			return;

		TInt length = aText.Length();

		TInt maxLength = iCheck->Length() - iPos;

		TPtrC mid = iCheck->Mid(iPos, length < maxLength? length : maxLength);

		if (aText.Compare(mid) != 0)

			iFailed = ETrue;

		else

			iPos += aText.Length();

		}

	};

class CStoringLogger : public CLogger

	{

	HBufC*	iStore;

	TInt	iMaxLength;

public:

	~CStoringLogger() { delete iStore; }

	HBufC* GetStore() { HBufC* r = iStore; iStore = 0; iMaxLength = 0; return r; }

	void Output(const TDesC& aText)

		{

		if (!iStore)

			{

			iStore = HBufC::NewL(50);

			iMaxLength = 50;

			}

		while (iMaxLength < aText.Length() + iStore->Length())

			{

			iMaxLength *= 2;

			iStore = iStore->ReAllocL(iMaxLength);

			}

		iStore->Des().Append(aText);

		};

	};

//

//

//  commands

//

//

// internal commands

class CCommandOffset;

class CCommandToggle;

class CTestCommand : public CSingleCommand

	{

public:

	TUid FamilyUid() const

		{

		return TUid::Uid(12345);

		}

	virtual CCommandOffset* CastToCCommandOffset() { return 0; }

	virtual CCommandToggle* CastToCCommandToggle() { return 0; }

	};

// Offset

class CCommandOffset : public CTestCommand

	{

	TInt	iOffset;

	TInt*	iTarget;

	CLogger* iLogger;

	CCommandOffset() {}

public:

	static CCommandOffset* NewL(TInt aOffset, TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandOffset* r = new(ELeave) CCommandOffset;

		r->iOffset = aOffset;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	void SetLogger(CLogger* aLogger) { iLogger = aLogger; }

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("offset") << iOffset;

		*iTarget += iOffset;

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		return NewL(-iOffset, iTarget, iLogger);

		}

	void Add(TInt aOffset) { iOffset += aOffset; }

	CCommandOffset* CastToCCommandOffset() { return this; }

	};

// Negate (only if iTog is ETrue!)

class CCommandToggle : public CTestCommand

	{

	TBool iTog;

	TInt* iTarget;

	CLogger* iLogger;

	CCommandToggle() {}

public:

	static CCommandToggle* NewL(TBool aTog, TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandToggle* r = new(ELeave) CCommandToggle;

		r->iTog = aTog;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	void SetLogger(CLogger* aLogger) { iLogger = aLogger; }

	TInt ExecuteL() const

		{

		if (iLogger)

			{

			(*iLogger) << _L("negate") << (iTog? 1:0);

			}

		if (iTog)

			*iTarget = -*iTarget;

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		return NewL(iTog, iTarget, iLogger);

		}

	void Add(TBool aTog)

		{

		if (aTog)

			iTog = !iTog;

		}

	CCommandToggle* CastToCCommandToggle() { return this; }

	};

// command prototypes

class CCommandIncProto : public CTestCommand

	{

	TInt*		iTarget;

	CLogger*	iLogger;

	CCommandIncProto() {}

public:

	static CCommandIncProto* NewL(TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandIncProto* r = new(ELeave) CCommandIncProto;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("inc<>");

		++*iTarget;

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		return CCommandOffset::NewL(-1, iTarget, iLogger);

		}

	TBool PrepareToAddInverseToLastL(CSingleCommand& aLastCommand) const

		{

		if (aLastCommand.FamilyUid() != TUid::Uid(12345))

			return EFalse;

		return !!static_cast<CTestCommand&>(aLastCommand).CastToCCommandOffset();

		}

	void AddInverseToLast(CSingleCommand& aLastCommand) const

		{

		CCommandOffset* c =

			static_cast<CTestCommand&>(aLastCommand).CastToCCommandOffset();

		ASSERT(c);

		c->Add(-1);

		}

	};

class CCommandDecProto : public CTestCommand

	{

	TInt*		iTarget;

	CLogger*	iLogger;

	CCommandDecProto() {}

public:

	static CCommandDecProto* NewL(TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandDecProto* r = new(ELeave) CCommandDecProto;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("dec<>");

		--*iTarget;

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		return CCommandOffset::NewL(1, iTarget, iLogger);

		}

	TBool PrepareToAddInverseToLastL(CSingleCommand& aLastCommand) const

		{

		if (aLastCommand.FamilyUid() != TUid::Uid(12345))

			return EFalse;

		return !!static_cast<CTestCommand&>(aLastCommand).CastToCCommandOffset();

		}

	void AddInverseToLast(CSingleCommand& aLastCommand) const

		{

		CCommandOffset* c =

			static_cast<CTestCommand&>(aLastCommand).CastToCCommandOffset();

		ASSERT(c);

		c->Add(1);

		}

	};

class CCommandNegProto : public CTestCommand

	{

	TInt*		iTarget;

	CLogger*	iLogger;

	CCommandNegProto() {}

public:

	static CCommandNegProto* NewL(TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandNegProto* r = new(ELeave) CCommandNegProto;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("neg<>");

		*iTarget = -*iTarget;

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		return CCommandToggle::NewL(ETrue, iTarget, iLogger);

		}

	TBool PrepareToAddInverseToLastL(CSingleCommand& aLastCommand) const

		{

		if (aLastCommand.FamilyUid() != TUid::Uid(12345))

			return EFalse;

		return !!static_cast<CTestCommand&>(aLastCommand).CastToCCommandToggle();

		}

	void AddInverseToLast(CSingleCommand& aLastCommand) const

		{

		CCommandToggle* c =

			static_cast<CTestCommand&>(aLastCommand).CastToCCommandToggle();

		ASSERT(c);

		c->Add(ETrue);

		}

	};

// command whose inverse is a batch command

class CCommandDecThenNegProto : public CTestCommand

	{

	TInt*		iTarget;

	CLogger*	iLogger;

	CCommandDecThenNegProto() {}

public:

	static CCommandDecThenNegProto* NewL(TInt* aTarget, CLogger* aLogger = 0)

		{

		CCommandDecThenNegProto* r = new(ELeave) CCommandDecThenNegProto;

		r->iTarget = aTarget;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("decneg<>");

		*iTarget = -(*iTarget - 1);

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		CBatchCommand* batch = CBatchCommand::NewLC();

		batch->PushL(CCommandOffset::NewL(1, iTarget, iLogger));

		batch->PushL(CCommandToggle::NewL(ETrue, iTarget, iLogger));

		CleanupStack::Pop(batch);

		return batch;

		}

	};

class CCommandCannotDo : public CTestCommand

	{

	CLogger*	iLogger;

public:

	static CCommandCannotDo* NewL(CLogger* aLogger)

		{

		CCommandCannotDo* r = new(ELeave) CCommandCannotDo;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("nodo<>");

		return KErrNotSupported;

		}

	CCommand* CreateInverseL() const

		{

		return 0;

		}

	};

class CCommandCannotInvert : public CTestCommand

	{

	CLogger*	iLogger;

public:

	static CCommandCannotInvert* NewL(CLogger* aLogger)

		{

		CCommandCannotInvert* r = new(ELeave) CCommandCannotInvert;

		r->iLogger = aLogger;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("noinv<>");

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		if (iLogger)

			(*iLogger) << _L("noinvfail.");

		User::Leave(KErrNotSupported);

		return 0;

		}

	};

class CCommandLeavesInvert : public CTestCommand

	{

	CLogger*	iLogger;

public:

	mutable TBool iFail;

	static CCommandLeavesInvert* NewL(CLogger* aLogger)

		{

		CCommandLeavesInvert* r = new(ELeave) CCommandLeavesInvert;

		r->iLogger = aLogger;

		r->iFail = ETrue;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iLogger)

			(*iLogger) << _L("leaveinv<>");

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		if (iFail)

			{

			iFail = EFalse;

			if (iLogger)

				(*iLogger) << _L("noinvfail.");

			User::Leave(KErrNotFound);

			}

		return 0;

		}

	};

class CCommandNoMemory : public CTestCommand

	{

	CLogger*	iLogger;

public:

	TBool iFailInvert;

	TBool iFailAddToLast;

	TBool iFailExecute;

	mutable TBool iLogExecuteFailed;

	static CCommandNoMemory* NewL(CLogger* aLogger)

		{

		CCommandNoMemory* r = new(ELeave) CCommandNoMemory;

		r->iLogger = aLogger;

		r->iFailInvert		= ETrue;

		r->iFailAddToLast	= ETrue;

		r->iFailExecute		= ETrue;

		r->iLogExecuteFailed= ETrue;

		return r;

		}

	TInt ExecuteL() const

		{

		if (iFailExecute)

			{

			if (iLogger && iLogExecuteFailed)

				(*iLogger) << _L("nomemfailexe.");

			iLogExecuteFailed = EFalse;

			User::Leave(KErrNoMemory);

			}

		if (iLogger)

			(*iLogger) << _L("nomem<>");

		return KErrNone;

		}

	CCommand* CreateInverseL() const

		{

		if (iFailInvert)

			{

			if (iLogger)

				(*iLogger) << _L("nomemfailinv.");

			User::Leave(KErrNoMemory);

			}

		return 0;

		}

	TBool PrepareToAddInverseToLastL(CSingleCommand&) const

		{

		if (iFailAddToLast)

			{

			if (iLogger)

				(*iLogger) << _L("nomemfailadd.");

			User::Leave(KErrNoMemory);

			}

		return EFalse;

		}

	};

// this gatekeeper refuses non-undoable requests

class CRefuserGatekeeper : public CBase, public MNotUndoableGatekeeper

	{

public:

	TBool RetryOutOfMemoryL(TInt)

		{

		return EFalse;

		}

	TBool AllowNotUndoableL(TInt)

		{

		return EFalse;

		}

	};

// this gatekeeper permits all non-undoable requests

// (not just KErrNotSupported and KErrNoMemory)

class CPermitterGatekeeper : public CBase, public MNotUndoableGatekeeper

	{

public:

	TBool RetryOutOfMemoryL(TInt)

		{

		return EFalse;

		}

	TBool AllowNotUndoableL(TInt)

		{

		return ETrue;