/*

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

* Test code for MTmSource functionality

*

*/

#include "TAGMA.H"

#include <e32test.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TAGMA_INTERNAL.H"

#endif

#include "ttmsource.h"

#define UNUSED_VAR(a) a = a

namespace LocalToTTmSource

{

CTTmSourceStep* TestStep = NULL;

#define TESTPOINT(p) TestStep->testpoint(p,(TText8*)__FILE__,__LINE__)

#define TESTPRINT(p) TestStep->print(p,(TText8*)__FILE__,__LINE__)

}

using namespace LocalToTTmSource;

class TTestGraphicsDeviceMap : public MGraphicsDeviceMap

	{

public:

	TInt HorizontalTwipsToPixels(TInt a) const { return a; }

	TInt VerticalTwipsToPixels(TInt a) const { return a; }

	TInt HorizontalPixelsToTwips(TInt a) const { return a; }

	TInt VerticalPixelsToTwips(TInt a) const { return a; }

	TInt GetNearestFontInTwips(CFont*&,const TFontSpec&)

		{

		return KErrGeneral;

		}

	void ReleaseFont(CFont*) {}

	};

class CTestPicture : public CPicture

	{

public:

	CTestPicture() {}

	virtual void Draw(CGraphicsContext&, const TPoint&, const TRect&, MGraphicsDeviceMap*) const {}

	virtual void ExternalizeL(RWriteStream&) const {}

	virtual void GetOriginalSizeInTwips(TSize&) const {}

	virtual TBool LineBreakPossible(TUint aClass,TBool aBeforePicture,TBool aHaveSpaces) const

		{

		++iRequestCount;

		if (aBeforePicture)

			{

            TESTPOINT(aClass == iClassBefore);

            TESTPOINT(aHaveSpaces == iSpacesBefore);

			return iResultBefore;

			}

		TESTPOINT(aClass == iClassAfter);

		TESTPOINT(aHaveSpaces == iSpacesAfter);

		return iResultAfter;

		}

	// expected parameters for LineBreakPossible

	TUint iClassBefore;

	TUint iClassAfter;

	TBool iSpacesBefore;

	TBool iSpacesAfter;

	// Results for breaking before/breaking after

	TBool iResultBefore;

	TBool iResultAfter;

	mutable TInt iRequestCount;

	};

class TTestSource : public MTmSource

	{

public:

	TTestSource() : iPicturePos(-1) {}

	virtual ~TTestSource() {}

	MGraphicsDeviceMap& FormatDevice() const { return iGDM; }

	MGraphicsDeviceMap& InterpretDevice() const { return iGDM; }

	TInt DocumentLength() const

		{

		return iText->Length();

		}

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

		{

		TTmCharFormat f;

		aFormat = f;

		aText.Set(iText->Mid(aPos));

		}

	void GetParagraphFormatL(TInt, RTmParFormat& aFormat) const

		{

		RTmParFormat p;

		aFormat.CopyL(p);

		}

	CPicture* PictureL(TInt aPos) const

		{

		return aPos == iPicturePos? iPicture : 0;

		}

	TInt ParagraphStart(TInt) const { return 0; }

	virtual TUint LineBreakClass(TUint aCode, TUint& aRangeStart,

		TUint& aRangeEnd) const

		{

		if ('@' == aCode)

			{

			aRangeStart = aRangeEnd = aCode;

			return ESaLineBreakClass;

			}

		if ('0' <= aCode && aCode <= '9')

			{

			aRangeStart = aRangeEnd = aCode;

			return ELineBreakClasses + aCode - '0';

			}

		return MTmSource::LineBreakClass(aCode, aRangeStart, aRangeEnd);

		}

	virtual TBool LineBreakPossible(TUint aPrevClass, TUint aNextClass,

		TBool aHaveSpaces) const

		{

		TInt first = static_cast<TInt>(aPrevClass);

		TInt second = static_cast<TInt>(aNextClass);

		TInt customCount = 0;

		if (iDirection < 0)

			{

			first = aNextClass;

			second = aPrevClass;

			}

		if (ELineBreakClasses <= first && first < ELineBreakClasses + 10)

			{

			++customCount;

			TESTPOINT(first - ELineBreakClasses + '0' == FindNextCustomClass());

			TInt countSpaces = CountSpaces();

			TESTPOINT(!aHaveSpaces == !countSpaces);

			}

		if (ELineBreakClasses <= second && second < ELineBreakClasses + 10)

			{

			++customCount;

			TInt c = FindNextCustomClass();

			TESTPOINT(second - ELineBreakClasses + '0' == c);

			}

		if (0 == customCount)

			return MTmSource::LineBreakPossible(aPrevClass, aNextClass, aHaveSpaces);

		// Between custom and non-custom classes, allow a break only with spaces

		// or between @ and 5

		if (1 == customCount)

			return aHaveSpaces

				|| (first == ESaLineBreakClass && second == ELineBreakClasses + 5)

				|| (second == ESaLineBreakClass && first == ELineBreakClasses + 5);

		// Allow a break with spaces except after '0' or before '9'

		if (aHaveSpaces)

			return aPrevClass != ELineBreakClasses && aNextClass != ELineBreakClasses + 9;

		// Allow a break only between a class and the class one more than it.

		return aPrevClass + 1 == aNextClass;

		}

	virtual TBool GetLineBreakInContext(

		const TDesC& aText, TInt aMinBreakPos, TInt aMaxBreakPos,

		TBool aForwards,TInt& aBreakPos) const

		{

	    TESTPOINT (iDirection == (aForwards? 1 : -1));

		// The allowable break-points should not include the first

		// and last characters of the run.

	    TESTPOINT (aMinBreakPos != 0);

		for (TInt i = aMinBreakPos - 1; i <= aMaxBreakPos; ++i)

		    TESTPOINT('@' == aText[i]);

		++iSaRequestCount;

		aBreakPos = iText->Ptr() + iSaBreakpoint - aText.Ptr();

		return aMinBreakPos <= aBreakPos && aBreakPos <= aMaxBreakPos;

		}

	virtual TBool IsHangingCharacter(TUint aChar) const

		{

		++iHangingCharRequestCount;

		TESTPOINT(aChar == (*iText)[iMaxBreakPos]);

		if (!iHangingChar)

			return EFalse;

		if (iDirection < 0)

			++iCurrentPos;

		return ETrue;

		}

	// non-virtual

	TBool GetLineBreakL(const TDesC& aText, TInt aDocPos,

		TInt aMinBreakPos, TInt aMaxBreakPos, TBool aForwards,

		TInt& aBreakPos, TInt& aHangingChars, TInt& aBreakPosAfterSpaces) const

		{

		iText = &aText;

		iMaxBreakPos = aMaxBreakPos;

		iMinBreakPos = aMinBreakPos;

		iHangingCharRequestCount = 0;

		iSaRequestCount = 0;

		iDirection = aForwards? 1 : -1;

		iCurrentPos = aForwards? aMinBreakPos : aMaxBreakPos - 1;

		TBool r = MTmSource::GetLineBreakL(aText, aDocPos,

			aMinBreakPos, aMaxBreakPos, aForwards,

			aBreakPos, aHangingChars, aBreakPosAfterSpaces);

		if (r)

			{

            TESTPOINT(aMinBreakPos <= aBreakPos);

            TESTPOINT(0 < aBreakPos);

            TESTPOINT(aBreakPos <= aHangingChars);

            TESTPOINT(aHangingChars <= aBreakPosAfterSpaces);

            TESTPOINT(aBreakPos <= aMaxBreakPos);

            TESTPOINT(aHangingChars == aBreakPos || iHangingChar);

			// If the direction was backwards, the algorithm should have

			// checked if a hanging character was allowed.

			// This condition could be relaxed to allow it not to be checked

			// if there is no break allowed between the possible hanging

			// character and the previous character.

            TESTPOINT(!aForwards || aText.Length() == aMaxBreakPos

				|| 0 < iHangingCharRequestCount);

			// If the maximum break point was chosen or exceeded, the algorithm

			// should have checked to find out whether a hanging character is

			// allowed.

            TESTPOINT(aHangingChars < aMaxBreakPos

				|| 0 < iHangingCharRequestCount);

			// Check that only spaces exist between aHangingChars and

			// aMaxBreakPos

			for (TInt i = aHangingChars; i != aBreakPosAfterSpaces; ++i)

				{

				TUint n;

				TESTPOINT(ESpLineBreakClass == LineBreakClass(aText[i], n, n));

				}

			// Check that all the spaces were counted

			TESTPOINT(aBreakPosAfterSpaces == aText.Length()

				|| aText[aBreakPosAfterSpaces] != ' ');

			}

		// Find out how many runs of two or more Sa there are, and check that

		// this matches the number of times that it was requested.

		TInt minChecked = aMinBreakPos - 1;

		TInt maxChecked = aMaxBreakPos + 2;

		if (r)

			{

			if (aForwards)

				maxChecked = aBreakPos + 1;

			else

				minChecked = aBreakPos - 1;

			}

		if (minChecked < 0)

			minChecked = 0;

		if (aText.Length() < maxChecked)

			maxChecked = aText.Length();

		TInt runs = 0;

		TInt sasSoFar = 0;

		TESTPOINT (maxChecked - minChecked < 2

			|| aText[minChecked] != '@'

			|| aText[minChecked + 1] != '@'

			|| !aForwards

			|| aHangingChars == iSaBreakpoint);

		for (; minChecked != maxChecked; ++minChecked)

			{

			if (aText[minChecked] == '@')

				++sasSoFar;

			else

				{

				if (1 < sasSoFar)

					++runs;

				sasSoFar = 0;

				}

			}

		if (1 < sasSoFar)

			++runs;

		TESTPOINT(sasSoFar < 2 || aForwards || aHangingChars == iSaBreakpoint);

		TESTPOINT(runs == iSaRequestCount);

		return r;

		}

	TInt FindNextCustomClass() const

		{

		TInt end = iDirection < 0? -1 : iText->Length();

		for (; iCurrentPos != end; iCurrentPos += iDirection)

			{

			TInt c = (*iText)[iCurrentPos];

			if ('0' <= c && c <= '9')

				return c;

			}

		return -1;

		}

	TInt CountSpaces() const

		{

		TInt end = iDirection < 0? -1 : iText->Length();

		TInt count = 0;

		if (iCurrentPos == end)

			return 0;

		iCurrentPos += iDirection;

		for (; iCurrentPos != end; iCurrentPos += iDirection, ++count)

			{

			TInt c = (*iText)[iCurrentPos];

			if (' ' != c)

				return count;

			}

		return count;

		}

private:

	mutable TTestGraphicsDeviceMap iGDM;

	mutable const TDesC* iText;

	mutable TInt iMaxBreakPos;

	mutable TInt iMinBreakPos;

	mutable TInt iDirection;

	mutable TInt iCurrentPos;

	mutable TInt iHangingCharRequestCount;

	mutable TInt iSaRequestCount;

public:

	TInt iPicturePos;

	CPicture* iPicture;

	TBool iHangingChar;

	TInt iSaBreakpoint;

	};

TInt TestLineBreak(const TDesC& aText, TInt aSaBreak, TBool aHangingChar,

	TInt aMin, TInt aMax, TBool aForwards)

	{

	if (aMax == 0)

		aMax = aText.Length();

	TTestSource t;

	t.iHangingChar = aHangingChar;

	t.iSaBreakpoint = aSaBreak;

	TInt b0, b1, b2;

	b0 = KMaxTInt;

	b1 = KMaxTInt;

	b2 = KMaxTInt;

	return t.GetLineBreakL(aText, 0, aMin, aMax, aForwards, b0, b1, b2)?

		b1 : -1;

	}

CTTmSourceStep::CTTmSourceStep()

    {

    }

TVerdict CTTmSourceStep::doTestStepL()

	{

    SetTestStepResult(EPass);

    TestStep = this;

    TESTPRINT(_L("TTmSource - MTmSource tests"));

	TESTPRINT(_L(" @SYMTestCaseID:SYSLIB-FORM-LEGACY-TTMSOURCE-0001 Line-Break Tests: "));

	TEST(-1 == TestLineBreak(_L(""), 0, 0, 0, 0, 0));

	TEST(-1 == TestLineBreak(_L("5"), 0, 0, 0, 0, 0));

	TEST(-1 == TestLineBreak(_L("5"), 0, 0, 0, 0, 1));

	TEST(-1 == TestLineBreak(_L("@"), 1, 0, 0, 0, 0));

	TEST(1 == TestLineBreak(_L("a   b"), 0, 0, 0, 0, 0));

	TEST(-1 == TestLineBreak(_L("0 0 0 9    9"), 0, 0, 0, 0, 0));

	TEST(-1 == TestLineBreak(_L("0 0 0 9    9"), 0, 0, 0, 0, 1));

	TEST(9 == TestLineBreak(_L("4242454445"), 0, 0, 0, 0, 0));

	TEST(5 == TestLineBreak(_L("4242454445"), 0, 0, 0, 0, 1));

	TEST(5 == TestLineBreak(_L("hello there"), 0, 0, 0, 0, 0));

	TEST(5 == TestLineBreak(_L("hello there"), 0, 0, 0, 0, 1));

	TEST(-1 == TestLineBreak(_L("hel  the re"), 0, 0, 5, 7, 0));

	TEST(-1 == TestLineBreak(_L("hel  the re"), 0, 0, 5, 7, 1));

	TEST(8 == TestLineBreak(_L("hel  the re"), 0, 1, 5, 7, 0));

	TEST(8 == TestLineBreak(_L("hel  the re"), 0, 1, 6, 7, 1));

	TEST(3 == TestLineBreak(_L("@@@@@"), 3, 0, 0, 0, 0));

	TEST(3 == TestLineBreak(_L("@@@@@"), 3, 0, 0, 0, 1));

	TEST(5 == TestLineBreak(_L("9999@@@@@00099@@@@gfra"), 5, 0, 5, 0, 0));

	TEST(5 == TestLineBreak(_L("9999@@@@@00099@@@@gfra"), 5, 0, 5, 0, 1));

	TEST(16 == TestLineBreak(_L("9999@@@@@00099@@@@gfra"), 16, 0, 0, 0, 0));

	TEST(16 == TestLineBreak(_L("9999@@@@@00099@@@@gfra"), 16, 0, 0, 0, 1));

	TEST(5 == TestLineBreak(_L("55@@@55"), 0, 0, 0, 0, 0));

	TEST(2 == TestLineBreak(_L("55@@@55"), 0, 0, 0, 0, 1));

	TEST(3 == TestLineBreak(_L("55@55"), 0, 0, 0, 0, 0));

	TEST(2 == TestLineBreak(_L("55@55"), 0, 0, 0, 0, 1));

	// Test for DEF046468, which was caused by the TLineBreakIterator constructor accessing past the end of a string

	TESTPRINT(_L("Line-Break DEF046468 Test:"));

	// Create a string of 16 chars with a picture code at the 17th position

	_LIT(KLarsString, "dolor sit amet, \xFFFC");

	// Create a TPtrC for the 16 character string ( with the picture code after the string in memory )

	TBufC<20> KTestBuffer(KLarsString);

	TPtrC KTestString( reinterpret_cast<const TUint16*>(KTestBuffer.Ptr()), 16);

	// Test the iterator overrun. If iterator accesses past the end of the array, it'll get picture code and crash

	TEST(9 == TestLineBreak(KTestString,0,0,1,15,0));

	return TestStepResult();

	}