/*

* Copyright (c) 2001-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: 

* TTagmaImp.cpp test file for Tagma classes

*

*/

#include "TGraphicsContext.h"

#include <e32test.h>

#include <e32std.h>

#include <coemain.h>

#include <gdi.h>

#include <txtlaydc.h>

#include "TAGMA.H"

#include "TMSTD.H"

#include "TmLayoutImp.h"

#include "TMINTERP.H"

#include "TmText.h"

#include "InlineText.h"

namespace LocalToFile

{

enum TTagmaImpPanic { EAccessOutsideText = 1 };

void Panic(TTagmaImpPanic)

	{

	User::Panic(_L("TTagmaImp"), EAccessOutsideText);

	}

RTest test(_L("Tagma internals tests"));

const TInt KPictureCharacter = 0xFFFC;

class CPinkSquare : public CPicture

	{

public:

	// Size of square in twips.

	// 600 is 15 pixels using the standard test graphics device at

	// its default resolution.

	enum { KWidth = 600, KHeight = 600 };

	CPinkSquare() {}

	void Draw(CGraphicsContext& aGc, const TPoint& aTopLeft,

		const TRect& aClipRect, MGraphicsDeviceMap* aMap) const

		{

		// This picture is a magenta square

		TPoint size(KWidth, KHeight);

		if (aMap)

			size = aMap->TwipsToPixels(size);

		TRect rect(aTopLeft, aTopLeft + size);

		aGc.SetClippingRect(aClipRect);

		aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);

		aGc.SetPenColor(KRgbMagenta);

		aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		aGc.SetBrushColor(KRgbMagenta);

		aGc.DrawRect(rect);

		}

	void ExternalizeL(RWriteStream&) const {}

	void GetOriginalSizeInTwips(TSize& a) const

		{

		a.iWidth = CPinkSquare::KWidth;

		a.iHeight = CPinkSquare::KHeight;

		}

	};

_LIT(KEnd, "\x2029");

class TDocModel : public MLayDoc

	{

public:

	TDocModel(const TDesC& aDes)

		: iDes(&aDes), iParagraphFormat(0) {}

	void SetParagraphFormat(CParaFormat* a)

		{

		iParagraphFormat = a;

		}

	// From MLayDoc

	TInt LdDocumentLength() const { return iDes->Length(); }

	TInt LdToParagraphStart(TInt& a) const

		{

		TInt curr = a;

		if (a < LdDocumentLength())

			{

			a = iDes->Left(a).LocateReverse(0x2029);

			a = a < 0? 0 : a + 1;

			}

		return curr - a;

		}

	void GetParagraphFormatL(CParaFormat* aFormat, TInt) const

		{

		if (iParagraphFormat)

			{

			aFormat->CopyL(*iParagraphFormat);

			return;

			}

		aFormat->Reset();

		TTabStop tabStop;

		tabStop.iTwipsPosition = 1000;

		tabStop.iType = TTabStop::ELeftTab;

		aFormat->StoreTabL(tabStop);

		}

	void GetChars(TPtrC& aView,TCharFormat& aFormat, TInt aStartPos)const

		{

		TCharFormat cf;

		aFormat = cf;

		if (aStartPos == LdDocumentLength())

			aView.Set(KEnd);

		else

			aView.Set(iDes->Mid(aStartPos));

		}

	TInt GetPictureSizeInTwips(TSize& aSize, TInt aPos) const

		{

		if ((*iDes)[aPos] != KPictureCharacter)

			return KErrNotFound;

		aSize.iWidth = CPinkSquare::KWidth;

		aSize.iHeight = CPinkSquare::KHeight;

		return KErrNone;

		}

	CPicture* PictureHandleL(TInt aPos, TForcePictureLoad) const

		{

		if ((*iDes)[aPos] != KPictureCharacter)

			return 0;

		return new(ELeave) CPinkSquare;

		}

	TBool EnquirePageBreak(TInt aPos, TInt aLength)const

		{

		return iDes->Mid(aPos, aLength).Locate(0x000C) < 0?

			EFalse : ETrue;

		}

	TBool SelectParagraphLabel(TInt) { return EFalse; }

	void CancelSelectLabel() {}

private:

	const TDesC* iDes;

	CParaFormat* iParagraphFormat;

	};

class THandleTester

	{

	TInt iProcessHandles;

	TInt iThreadHandles;

	RTest& iTest;

public:

	THandleTester(RTest& rt) : iTest(rt)

		{

		RThread().HandleCount(iProcessHandles, iThreadHandles);

		}

	~THandleTester()

		{

		TInt p;

		TInt t;

		RThread().HandleCount(p, t);

// this seems to break at random...

//		iTest(p == iProcessHandles);

		iTest(t == iThreadHandles);

		}

	};

class CFallableDeviceMap : public CBase, public MGraphicsDeviceMap

	{

	MGraphicsDeviceMap& iDeviceMap;

public:

	CFallableDeviceMap(MGraphicsDeviceMap& aDeviceMap) : iDeviceMap(aDeviceMap) {}

	TInt HorizontalTwipsToPixels(TInt aTwips) const

		{

		return iDeviceMap.HorizontalTwipsToPixels(aTwips);

		}

	TInt VerticalTwipsToPixels(TInt aTwips) const

		{

		return iDeviceMap.VerticalTwipsToPixels(aTwips);

		}

	TInt HorizontalPixelsToTwips(TInt aPixels) const

		{

		return iDeviceMap.HorizontalPixelsToTwips(aPixels);

		}

	TInt VerticalPixelsToTwips(TInt aPixels) const

		{

		return iDeviceMap.VerticalPixelsToTwips(aPixels);

		}

	TInt GetNearestFontInTwips(CFont*& aFont,const TFontSpec& aFontSpec)

		{

		TInt *i = new TInt;

		if (i)

			{

			delete i;

			return iDeviceMap.GetNearestFontInTwips(aFont, aFontSpec);

			}

		return KErrNoMemory;

		}

	void ReleaseFont(CFont* aFont)

		{

		iDeviceMap.ReleaseFont(aFont);

		}

	};

class CTestSource : public CBase, public MTmSource

	{

	MGraphicsDeviceMap* iDeviceMap;

	TPtrC iText;

	TTmCharFormat iDefaultCharFormat;

	TTmCharFormat iSpecialCharFormat;

	TInt iBeginSpecialCharFormat;

	TInt iEndSpecialCharFormat;

public:

	~CTestSource()

		{

		delete iDeviceMap;

		}

	CTestSource(const TDesC& aText,

		TTmCharFormat aDefault, TTmCharFormat aSpecial,

		TInt aBeginSpecialCharFormat, TInt aEndSpecialCharFormat)

		: iText(aText),

		iDefaultCharFormat(aDefault), iSpecialCharFormat(aSpecial),

		iBeginSpecialCharFormat(aBeginSpecialCharFormat),

		iEndSpecialCharFormat(aEndSpecialCharFormat)

		{

		}

	void ConstructL(MGraphicsDeviceMap& aDeviceMap)

		{

		iDeviceMap = new(ELeave) CFallableDeviceMap(aDeviceMap);

		}

	MGraphicsDeviceMap& FormatDevice() const { return *iDeviceMap; }

	MGraphicsDeviceMap& InterpretDevice() const { return *iDeviceMap; }

	TInt DocumentLength() const { return iText.Length(); }

	void SetText(const TDesC& aStaticText)

		{

		iText.Set(aStaticText);

		}

	void GetText(TInt aPos, TPtrC& aText, TTmCharFormat& aFormat) const

		{

		TInt length = iText.Length()+1;

		if (aPos < iBeginSpecialCharFormat)

			{

			length = iBeginSpecialCharFormat;

			aFormat = iDefaultCharFormat;

			}

		else if (aPos < iEndSpecialCharFormat)

			{

			length = iEndSpecialCharFormat;

			aFormat = iSpecialCharFormat;

			}

		else

			{

			aFormat = iDefaultCharFormat;

			}

		if (aPos == length)

			aText.Set(0, 0);

		else

			aText.Set(&iText[aPos], length - aPos);

		}

	void GetParagraphFormatL(TInt, RTmParFormat& aFormat) const

		{

		RTmParFormat defParFormat;

		CleanupClosePushL(defParFormat);

		aFormat.CopyL(defParFormat);

		CleanupStack::PopAndDestroy();

		}

	TInt ParagraphStart(TInt aPos) const

		{

		if (aPos <= iText.Length())

			aPos = iText.Length() - 1;

		TPtrC p(&iText[0], aPos + 1);

		TInt delim = p.LocateReverse(TChar(CEditableText::EParagraphDelimiter));

		return delim < 0? 0 : delim + 1;

		}

	CPicture* PictureL(TInt aPos) const

		{

		// There are no pictures, but we need to check that code never tries to

		// take one from beyond the bounds of the text.

		__ASSERT_ALWAYS(0 <= aPos, Panic(EAccessOutsideText));

		__ASSERT_ALWAYS(aPos < iText.Length(), Panic(EAccessOutsideText));

		return 0;

		}

	};

}

using namespace LocalToFile;

class CTagmaImpTest : public CBase

	{

public:

	CTagmaImpTest() : iDevice(0), iGc(0)

		{

		}

	void ConstructL()

		{

		TSize size(100, 100);

		iDevice = CTestGraphicsDevice::NewL(size, 0);

		iDevice->CreateContext(iGc);

 		}

 	~CTagmaImpTest()

 		{

 		delete iDevice;

 		}

	void ExerciseCTmCodeL();

	void AddSome1L(CTmCode& aCode, TInt aStartValue);

	TInt AddLotsL(CTmCode& aCode, TInt aAmountToAdd);

	TInt InsertSomeL(CTmCode& aCode, TInt aStartValue, TInt aIndex);

	TInt InsertLotsL(CTmCode& aCode, TInt aAmountToAdd, TInt aIndex);

	TInt CheckLots(CTmCode& aCode, TInt aIndex, TInt aStartValue, TInt aCount);

	void CTmCodeOOML();

	CTestSource* NewTestSourceLC();

	CTmCode* NewFormattedCTmCodeLC(MTmSource&);

	void ExerciseFormatL();

	void FormatOOML();

	void ExerciseRTmTextCacheWidthL();

	void RTmTextCacheWidthOOM();

	void ExerciseRTmGeneralInterpreterGetDisplayedTextL();

	void RTmGeneralInterpreterGetDisplayedTextOOM();

	void CTmTextImp_RRunArrayL();

	void WEP_55BHBF_DefectL();

	void BUR_58FGE8_DefectL();

	void EXT_5ATF8D_DefectL();

	void INC_044969_DefectL();

	void DEF_073838_DefectL();

	void PDEF_101464_DefectL();

	void DEF101994_DefectL();

	void CTmTextImp_BidirectionalAlignmentL();

	void ExerciseCopyL();

	void ExerciseGetCParaFormatL();

	void CustomFormattingL();

	void TestChunkContext();

	void TestBytecodeLineContext();

	void TestBytecodeChunkContext();

	void TestL();

	void GetIndices(TDes8& aBuf, const CTmTextImp::RRunArray& aRunArray);

	// Function to test the API's of CTmTextImp

	void TestAPIL();

	private:

	CTestGraphicsDevice* iDevice;

	CGraphicsContext* iGc;

	};

TInt CTagmaImpTest::CheckLots(CTmCode& aCode, TInt aIndex,

	TInt aStartValue, TInt aCount)

	{

	TTmCodeReader reader(aCode, aIndex, aCode.Size());

	for (; aCount; --aCount, aStartValue += 6)

		{

		TUint8 byte = reader.ReadByte();

		TInt num = reader.ReadNumber();

		TRect rect = reader.ReadRect();

		TRect testRect(aStartValue + 2, aStartValue + 3, aStartValue + 4, aStartValue + 5);

		test(byte == static_cast<TUint8>(aStartValue));

		test(num == aStartValue + 1);

		test(rect == testRect);

		}

	return reader.CodePos();

	}

void CTagmaImpTest::AddSome1L(CTmCode& aCode, TInt aStartValue)

	{

	aCode.AppendByteL(static_cast<TUint8>(aStartValue));

	aCode.AppendNumberL(aStartValue + 1);

	TRect rect(aStartValue + 2, aStartValue + 3, aStartValue + 4, aStartValue + 5);

	aCode.AppendRectL(rect);

	}

TInt CTagmaImpTest::AddLotsL(CTmCode& aCode, TInt aAmountToAdd)

	{

	TInt finalSize = aAmountToAdd + aCode.Size();

	TInt count = 0;

	for (TInt i = 0; aCode.Size() < finalSize; i += 6)

		{

		AddSome1L(aCode, i);

		++count;

		}

	return count;

	}

TInt CTagmaImpTest::InsertSomeL(CTmCode& aCode, TInt aStartValue, TInt aIndex)

	{

	TInt offset = aIndex - aCode.Size();

	aCode.InsertByteL(static_cast<TUint8>(aStartValue), aIndex);

	aCode.InsertNumberL(aStartValue + 1, aCode.Size() + offset);

	TRect rect(aStartValue + 2, aStartValue + 3, aStartValue + 4, aStartValue + 5);

	aCode.InsertRectL(rect, aCode.Size() + offset);

	return aCode.Size() + offset;

	}

TInt CTagmaImpTest::InsertLotsL(CTmCode& aCode, TInt aAmountToAdd, TInt aIndex)

	{

	TInt finalSize = aAmountToAdd + aCode.Size();

	TInt count = 0;

	for (TInt i = 0; aCode.Size() < finalSize; i += 6)

		{

		aIndex = InsertSomeL(aCode, i, aIndex);

		++count;

		}

	return count;

	}

void CTagmaImpTest::ExerciseCTmCodeL()

	{

	CTmCode* code = new (ELeave) CTmCode;

	CleanupStack::PushL(code);

	code->CreateBufferL();

	TInt count1 = AddLotsL(*code, 400);

	TInt size1 = code->Size();

	TInt count2 = AddLotsL(*code, 2000);

	TInt size2 = code->Size() - size1;

	TInt count3 = InsertLotsL(*code, 997, size1);

	TInt size3 = code->Size() - size1 - size2;

	CheckLots(*code, 0, 0, count1);

	CheckLots(*code, size1, 0, count3);

	CheckLots(*code, size1 + size3, 0, count2);

	CTmCode* code2 = new (ELeave) CTmCode;

	CleanupStack::PushL(code2);

	code2->CreateBufferL();

	TInt count4 = AddLotsL(*code2, 3000);

	TInt size4 = code2->Size();

	code->ChangeL(size1, size1 + size3, *code2);

	CheckLots(*code, 0, 0, count1);

	CheckLots(*code, size1, 0, count4);

	CheckLots(*code, size1 + size4, 0, count2);

	code->Delete(size1, size4);

	CheckLots(*code, 0, 0, count1);

	CheckLots(*code, size1, 0, count2);

	test(code2->Size() == 0);

	CleanupStack::PopAndDestroy(code2);

	CleanupStack::PopAndDestroy(code);

	}

void CTagmaImpTest::CTmCodeOOML()

	{

	ExerciseCTmCodeL();

	TInt err;

	TInt failAt = 1;

	do {

		THandleTester h(test);

		__UHEAP_MARK;

		__UHEAP_SETFAIL(RHeap::EDeterministic, failAt);

		TRAP(err, ExerciseCTmCodeL());

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		__UHEAP_MARKENDC(0);

		++failAt;

		} while (err == KErrNoMemory);

	test(err == KErrNone);

	}

CTestSource* CTagmaImpTest::NewTestSourceLC()

	{

	_LIT(KTestText, "Some text for you to format for me.\x2029");

	TTmCharFormat defCharFormat(_L("SwissA"), 60);

	TTmCharFormat specialCharFormat(_L("Arial"), 50);

	CTestSource* source = new(ELeave) CTestSource(KTestText,

		defCharFormat, specialCharFormat, 5, 9);

	CleanupStack::PushL(source);

	source->ConstructL(*iDevice);

	return source;

	}

CTmCode* CTagmaImpTest::NewFormattedCTmCodeLC(MTmSource& aSource)

	{

	CTmCode* code = new(ELeave) CTmCode;

	CleanupStack::PushL(code);

	TTmFormatParam formatParam;

	formatParam.iStartChar = 0;

	formatParam.iEndChar = aSource.DocumentLength();

	formatParam.iLineInPar = 0;

	formatParam.iWrapWidth = 50;

	formatParam.iMaxHeight = KMaxTInt;

	formatParam.iMaxLines = KMaxTInt;

	formatParam.iFlags = TTmFormatParam::EWrap;

	CTmFormatContext::TInfo info;

	CTmTextLayout *layout = new(ELeave) CTmTextLayout;

	CleanupStack::PushL(layout);

	CTmFormatContext::FormatL(aSource, formatParam, *code, info, layout);

	CleanupStack::PopAndDestroy(layout);

	return code;

	}

void CTagmaImpTest::ExerciseFormatL()

	{

	CTestSource* source = NewTestSourceLC();

	CTmCode* code = NewFormattedCTmCodeLC(*source);

	CleanupStack::PopAndDestroy(code);

	CleanupStack::PopAndDestroy(source);

	}

void CTagmaImpTest::FormatOOML()

	{

	// dry run- this will help the typeface store to settle down.

	ExerciseFormatL();

	TInt err;

	TInt failAt = 1;

	do {

		THandleTester h(test);

		__UHEAP_MARK;

		__UHEAP_SETFAIL(RHeap::EDeterministic, failAt);

		TRAP(err, ExerciseFormatL());

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		__UHEAP_MARKENDC(0);

		++failAt;

		} while (err == KErrNoMemory);

	test(err == KErrNone);

	}

void CTagmaImpTest::ExerciseRTmTextCacheWidthL()

	{

	_LIT(KOnions, "How easily happiness starts, slicing onions.\x2029");

	TTmCharFormat defCharFormat(_L("SwissA"), 60);

	TTmCharFormat specialCharFormat(_L("Arial"), 50);

	CTestSource* source = new (ELeave) CTestSource(KOnions,

		defCharFormat, specialCharFormat, 11, 20);

	CleanupStack::PushL(source);

	source->ConstructL(*iDevice);

	RTmTextCache textCache(*source, source->FormatDevice());

	CleanupClosePushL(textCache);

	textCache.TotalWidthL(0, KOnions().Length(), EFalse);

	textCache.AdvanceWidthL(0, KOnions().Length(), EFalse);

	CleanupStack::PopAndDestroy();

	CleanupStack::PopAndDestroy(source);

	}