/*

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

* TPARSE.CPP

*

*/

#include <txtrich.h>

#include <e32math.h>

#include "T_parse.h"

#include "T_PARSE_for_TEF.h"

LOCAL_D CTestStep *pTestStep = NULL;

#define test(cond)											\

	{														\

	TBool __bb = (cond);									\

	pTestStep->TEST(__bb);									\

	if (!__bb)												\

		{													\

		pTestStep->ERR_PRINTF1(_L("ERROR: Test Failed"));	\

		User::Leave(1);										\

		}													\

	}

#undef INFO_PRINTF1

#undef INFO_PRINTF2

#undef INFO_PRINTF3

// copy from tefexportconst.h

#define INFO_PRINTF1(p1)            pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1))

#define INFO_PRINTF2(p1, p2)        pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2))

#define INFO_PRINTF3(p1, p2, p3)    pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3))

LOCAL_D CTrapCleanup* TrapCleanup;

LOCAL_D const TInt KTestCleanupStack=0x200;

CTestParser* CTestParser::NewL()

	{

	CTestParser* self = new (ELeave) CTestParser;

	CleanupStack::PushL(self);

	self->iDoItText = HBufC::NewL(128);

	*(self->iDoItText) = _L("Or is it just undead?");

	CleanupStack::Pop();

	return self;

	}

CTestParser::CTestParser()

	{

	}

CTestParser::~CTestParser()

	{

	delete iDoItText;

	}

TBool CTestParser::ParseThisText(const CRichText& aTextObj, TBool aAllowBack,

									TInt aStartScan, TInt aScanLength,

									TInt& aStartTag, TInt& aTagLength)

	{

	// Very simple - looking for the phrase "the world"

	_LIT(targetText, "TARGET");

	TInt length = 6;

	// Consider that the start of the scan may be part way through

	// the item that we are looking for, so see if we need to move back

	TInt start = aStartScan;

	if (aAllowBack)

		{

		if (start >= length - 1)

			start -= length - 1;

		else

			start = 0;

		}

	// And it might go beyond the end of the scan

	TInt end = aStartScan + aScanLength;

	if (end + length - 1 <= aTextObj.DocumentLength())

		end += length - 1;

	else

		end = aTextObj.DocumentLength();

	while (end - start >= length)

		{

		TPtrC buffer = aTextObj.Read(start, end - start);

		TInt segmentLength= buffer.Length();

		if (segmentLength >= length)	// There's enough text to bother searching

			{

			TInt result = buffer.FindF(targetText);

			if (result != KErrNotFound)	// We found it

				{

				aStartTag = start + result;

				aTagLength = length;

				return ETrue;

				}

			}

		if (end == start + segmentLength)	// There's no more text at all

			break;

		// The buffer is segmented and there's another segment 

		// It could be over the segment boundary

		TInt start2 = start + segmentLength;

		TInt end2 = start2;

		if (segmentLength >= length - 1)

			start2 -= length - 1;

		else start2 = start;

		if (end >= end2 + length - 1)

			end2 += length -1;

		else

			end2 = end;

		if (end2 - start2 >= length)

			{

			// Create a buffer with the end of one and the start of the other

			TBuf<10> bridgeBuffer;

			aTextObj.Extract(bridgeBuffer, start2, end2 - start2);

			TInt result = bridgeBuffer.FindF(targetText);

			if (result != KErrNotFound)	// We found it

				{

				aStartTag = start2 + result;

				aTagLength = length;

				return ETrue;

				}

			}

		// Move start up for next segment

		start += segmentLength;

		}

		return EFalse;	// Not enough text left in buffer

	}

const TDesC& CTestParser::CreateDoItText(const CRichText& /* aTextObj */,

							TInt /* aStartText */, TInt /* aLength */)

	{

	return *iDoItText;

	}

void CTestParser::ActivateThisTextL(const CRichText& /* aTextObj */,

					  TInt /* aStartText */, TInt /* aLength */)

	{

	// Do something?

	}

void CTestParser::GetRecogniseFormat(TCharFormat& aFormat)

	{

	aFormat.iFontPresentation.iTextColor = KRgbRed;

	aFormat.iFontPresentation.iUnderline = EUnderlineOn;

	}

void CTestParser::GetRolloverFormat(TCharFormat& aFormat)

	{

	aFormat.iFontPresentation.iTextColor = KRgbRed;

	aFormat.iFontPresentation.iUnderline = EUnderlineOn;

	aFormat.iFontPresentation.iHighlightColor = KRgbDarkRed;

	aFormat.iFontPresentation.iHighlightStyle = TFontPresentation::EFontHighlightRounded;

	}

void CTestParser::Release()

	{

	delete this;

	}

//--------------------------------------------

CTestParser2* CTestParser2::NewL()

	{

	CTestParser2* self = new (ELeave) CTestParser2;

	CleanupStack::PushL(self);

	self->iDoItText = HBufC::NewL(128);

	*(self->iDoItText) = _L("Or is it just undead?");

	CleanupStack::Pop();

	return self;

	}

CTestParser2::CTestParser2()

	{

	}

CTestParser2::~CTestParser2()

	{

	delete iDoItText;

	}

TBool CTestParser2::ParseThisText(const CRichText& aTextObj, TBool aAllowBack,

									TInt aStartScan, TInt aScanLength,

									TInt& aStartTag, TInt& aTagLength)

	{

	// Very simple - looking for the phrase "ARG"

	_LIT(targetText, "ARG");

	TInt length = 3;

	// Consider that the start of the scan may be part way through

	// the item that we are looking for, so see if we need to move back

	TInt start = aStartScan;

	if (aAllowBack)

		{

		if (start >= length - 1)

			start -= length - 1;

		else

			start = 0;

		}

	// And it might go beyond the end of the scan

	TInt end = aStartScan + aScanLength;

	if (end + length - 1 <= aTextObj.DocumentLength())

		end += length - 1;

	else

		end = aTextObj.DocumentLength();

	while (end - start >= length)

		{

		TPtrC buffer = aTextObj.Read(start, end - start);

		TInt segmentLength= buffer.Length();

		if (segmentLength >= length)	// There's enough text to bother searching

			{

			TInt result = buffer.FindF(targetText);

			if (result != KErrNotFound)	// We found it

				{

				aStartTag = start + result;

				aTagLength = length;

				return ETrue;

				}

			}

		if (end == start + segmentLength)	// There's no more text at all

			break;

		// The buffer is segmented and there's another segment 

		// It could be over the segment boundary

		TInt start2 = start + segmentLength;

		TInt end2 = start2;

		if (segmentLength >= length - 1)

			start2 -= length - 1;

		else start2 = start;

		if (end >= end2 + length - 1)

			end2 += length -1;

		else

			end2 = end;

		if (end2 - start2 >= length)

			{

			// Create a buffer with the end of one and the start of the other

			TBuf<10> bridgeBuffer;

			aTextObj.Extract(bridgeBuffer, start2, end2 - start2);

			TInt result = bridgeBuffer.FindF(targetText);

			if (result != KErrNotFound)	// We found it

				{

				aStartTag = start2 + result;

				aTagLength = length;

				return ETrue;

				}

			}

		// Move start up for next segment

		start += segmentLength;

		}

		return EFalse;	// Not enough text left in buffer

	}

const TDesC& CTestParser2::CreateDoItText(const CRichText& /* aTextObj */,

							TInt /* aStartText */, TInt /* aLength */)

	{

	return *iDoItText;

	}

void CTestParser2::ActivateThisTextL(const CRichText& /* aTextObj */,

					  TInt /* aStartText */, TInt /* aLength */)

	{

	// Do something?

	}

void CTestParser2::GetRecogniseFormat(TCharFormat& aFormat)

	{

	aFormat.iFontPresentation.iTextColor = KRgbRed;

	aFormat.iFontPresentation.iUnderline = EUnderlineOn;

	}

void CTestParser2::GetRolloverFormat(TCharFormat& aFormat)

	{

	aFormat.iFontPresentation.iTextColor = KRgbRed;

	aFormat.iFontPresentation.iUnderline = EUnderlineOn;

	aFormat.iFontPresentation.iHighlightColor = KRgbDarkRed;

	aFormat.iFontPresentation.iHighlightStyle = TFontPresentation::EFontHighlightRounded;

	}

void CTestParser2::Release()

	{

	delete this;

	}

//--------------------------------------------

CEditObserver::CEditObserver()

	{

	iStart = 0;

	iExtent = 0;

	}

CEditObserver::~CEditObserver()

	{

	}

void CEditObserver::EditObserver(TInt aStart, TInt aExtent)

	{

	iStart = aStart;

	iExtent = aExtent;

	}

void Test1()

	{

	INFO_PRINTF1(_L("Install 5, deinstall in reverse order"));

	CTestParser* parser1 = CTestParser::NewL();

	CTestParser* parser2 = CTestParser::NewL();

	CTestParser* parser3 = CTestParser::NewL();

	CTestParser* parser4 = CTestParser::NewL();

	CTestParser* parser5 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);	// List 1

	CRichText::ActivateParserL(parser2);	// List 1, 2

	CRichText::ActivateParserL(parser3);	// List 1, 2, 3

	CRichText::ActivateParserL(parser4);	// List 1, 2, 3, 4

	CRichText::ActivateParserL(parser5);	// List 1, 2, 3, 4, 5

	CRichText::DeactivateParser(parser5);	// List 1, 2, 3, 4

	CRichText::DeactivateParser(parser4);	// List 1, 2, 3

	CRichText::DeactivateParser(parser3);	// List 1, 2

	CRichText::DeactivateParser(parser2);	// List 1

	CRichText::DeactivateParser(parser1);	// List empty

	delete parser5;

	delete parser4;

	delete parser3;

	delete parser2;

	delete parser1;

	CRichText::DeactivateParserDefaults();

	}

void Test2()

	{

	INFO_PRINTF1(_L("Install, deinstall in interleaved order"));

	CTestParser* parser1 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);	// List 1

	CTestParser* parser2 = CTestParser::NewL();

	CRichText::ActivateParserL(parser2);	// List 1, 2

	// Remove first in list

	CRichText::DeactivateParser(parser1);	// List 2

	delete parser1;

	CTestParser* parser3 = CTestParser::NewL();

	CRichText::ActivateParserL(parser3);	// List 2, 3

	// Remove last in list

	CRichText::DeactivateParser(parser3);	// List 2

	delete parser3;

	CTestParser* parser4 = CTestParser::NewL();

	CRichText::ActivateParserL(parser4);	// List 2, 4

	CTestParser* parser5 = CTestParser::NewL();

	CRichText::ActivateParserL(parser5);	// List 2, 4, 5

	// Remove middle in list

	CRichText::DeactivateParser(parser4);	// List 2, 5

	delete parser4;

	// Empty list

	CRichText::DeactivateParser(parser5);	// List 2

	delete parser5;

	CRichText::DeactivateParser(parser2);	// List empty

	delete parser2;

	CRichText::DeactivateParserDefaults();

	}

void Test3()

	{

	INFO_PRINTF1(_L("Testing memory with OOM"));

	TInt i;

	TInt ret;

	TInt count = 0;

	TInt success = 0;

	for (i = 0; i < 20; i++)

		{

		CTestParser* parser1 = NULL;

		CTestParser* parser2 = NULL;

		CTestParser* parser3 = NULL;

		CTestParser* parser4 = NULL;

		CTestParser* parser5 = NULL;

		// Switch on memory problems, varying fail rate from 20 to 1

		__UHEAP_SETFAIL(RHeap::EDeterministic, 20 - i);

		__UHEAP_MARK;

		count++;

		TRAP(ret, parser1 = CTestParser::NewL());

		if (ret != KErrNone)

			{

			parser1 = NULL;

			}

		else

			{

			TRAP(ret, CRichText::ActivateParserL(parser1));

			if (ret != KErrNone)

				{

				delete parser1;

				parser1 = NULL;

				}

			}

		TRAP(ret, parser2 = CTestParser::NewL());

		if (ret != KErrNone)

			{

			parser2 = NULL;

			}

		else

			{

			TRAP(ret, CRichText::ActivateParserL(parser2));

			if (ret != KErrNone)

				{

				delete parser2;

				parser2 = NULL;

				}

			}

		TRAP(ret, parser3 = CTestParser::NewL());

		if (ret != KErrNone)

			{

			parser3 = NULL;

			}

		else

			{

			TRAP(ret, CRichText::ActivateParserL(parser3));

			if (ret != KErrNone)

				{

				delete parser3;

				parser3 = NULL;

				}

			}

		TRAP(ret, parser4 = CTestParser::NewL());

		if (ret != KErrNone)

			{

			parser4 = NULL;

			}

		else

			{

			TRAP(ret, CRichText::ActivateParserL(parser4));

			if (ret != KErrNone)

				{

				delete parser4;

				parser4 = NULL;

				}

			}

		TRAP(ret, parser5 = CTestParser::NewL());

		if (ret != KErrNone)

			{

			parser5 = NULL;

			}

		else

			{

			TRAP(ret, CRichText::ActivateParserL(parser5));

			if (ret != KErrNone)

				{

				delete parser5;

				parser5 = NULL;

				}

			}

		if (parser1)

			{

			success++;

			CRichText::DeactivateParser(parser1);

			delete parser1;

			}

		if (parser2)

			{

			success++;

			CRichText::DeactivateParser(parser2);

			delete parser2;

			}

		if (parser3)

			{

			success++;

			CRichText::DeactivateParser(parser3);

			delete parser3;

			}

		if (parser4)

			{

			success++;

			CRichText::DeactivateParser(parser4);

			delete parser4;

			}

		if (parser5)

			{

			success++;

			CRichText::DeactivateParser(parser5);

			delete parser5;

			}

		CRichText::DeactivateParserDefaults();

		// Switch off memory problems

		__UHEAP_MARKEND;

		__UHEAP_RESET;

		}

	INFO_PRINTF3(_L("%d attempted activations, %d successful\n"), 5 * count, success);

	}

void Test4()

	{

	// Create a block of 1000 chars

	// Randomly insert a target string and check:

	// - Can't find target that is not complete

	// - Does find complete target in right place

	// - Once target is removed, can't find it

	// repeat x 100

	INFO_PRINTF1(_L("Testing EText behaviour with active parsers and single target"));

	// Create and activate a parser

	CTestParser* parser1 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);

	// Create a CRichText

	CParaFormatLayer* GlobalParaFormatLayer = CParaFormatLayer::NewL();

	CCharFormatLayer* GlobalCharFormatLayer = CCharFormatLayer::NewL();

	CRichText* richText = CRichText::NewL(GlobalParaFormatLayer, GlobalCharFormatLayer, CEditableText::ESegmentedStorage, CEditableText::EDefaultTextGranularity);

	richText->SetPictureFactory(NULL, NULL);  // forces index generation

	// Switch on parsers for this CRichText

	CEditObserver* editObserver = new (ELeave) CEditObserver;

	richText->SetEditObserver(editObserver);

	// Insert 1000 chars (repeated string)

	TInt i;

	for (i = 0; i < 100; i++)

		richText->InsertL(richText->DocumentLength(), _L("abcdefghij"));

	TInt64 seed = 314159;

	TInt startTags;

	TInt lengthTags;

	for (i = 0; i < 100; i++)

		{

#if 0

		INFO_PRINTF2(_L("i=%d"), i);

#endif

		// Get a random in range 0-999

		TInt random = Math::Rand(seed) % 1000;

		// "Randomly" insert target string that is not complete

		richText->InsertL(random, _L("TARGE"));

		test(!richText->ParseText(startTags, lengthTags, EFalse));

		test(!richText->ParseText(startTags, lengthTags, ETrue));

		// Complete target string and check we find single target where we expect

		richText->InsertL(random + 5, 'T');

#if 1

		test(richText->ParseText(startTags, lengthTags, EFalse));

#else

		TBool b = richText->ParseText(startTags, lengthTags, EFalse);

		INFO_PRINTF2(_L("    b=%d"), b);

		test(b);

#endif

		test((startTags == random) && (lengthTags == 6));

		test(richText->ParseText(startTags, lengthTags, ETrue));

		test((startTags == random) && (lengthTags == 6));

		// Completely remove target string

		richText->DeleteL(random, 6);

		test(!richText->ParseText(startTags, lengthTags, EFalse));

		test(!richText->ParseText(startTags, lengthTags, ETrue));

		}

	// Clean up

	delete richText;

	delete GlobalCharFormatLayer;

	delete GlobalParaFormatLayer;

	CRichText::DeactivateParser(parser1);

	delete parser1;

	CRichText::DeactivateParserDefaults();

	delete editObserver;

	}

void Test5()

	{

	// Create a block of 1000 chars

	// Randomly insert two target strings and check:

	// - Can't find targets that are not complete

	// - Does find complete targets with exact range covered

	// - Once targets are removed, can't find it

	// repeat x 100

	INFO_PRINTF1(_L("Testing EText behaviour with active parsers and double target"));

	// Create and activate a parser

	CTestParser* parser1 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);

	// Create a CRichText

	CParaFormatLayer* GlobalParaFormatLayer = CParaFormatLayer::NewL();

	CCharFormatLayer* GlobalCharFormatLayer = CCharFormatLayer::NewL();

	CRichText* richText = CRichText::NewL(GlobalParaFormatLayer, GlobalCharFormatLayer, CEditableText::ESegmentedStorage, CEditableText::EDefaultTextGranularity);

	richText->SetPictureFactory(NULL, NULL);  // forces index generation

	// Switch on parsers for this CRichText

	CEditObserver* editObserver = new (ELeave) CEditObserver;

	richText->SetEditObserver(editObserver);

	// Insert 1000 chars (repeated string)

	TInt i;

	for (i = 0; i < 100; i++)

		richText->InsertL(richText->DocumentLength(), _L("abcdefghij"));

	TInt64 seed1 = 314159;

	TInt startTags;

	TInt lengthTags;

	for (i = 0; i < 100; i++)

		{

#if 0

		INFO_PRINTF2(_L("i=%d"), i);

#endif

		// Get a random in range 0-999

		TInt random1 = Math::Rand(seed1) % 1000;

		TInt random2 = Math::Rand(seed1) % 1000;

		TInt rlow = (random1 < random2) ? random1 : random2;

		TInt rhigh = (random1 > random2) ? random1 : random2;

		if (rlow + 7 > rhigh)

			{ // Too close, spread them out

			if (rhigh + 7 <= richText->DocumentLength())

				rhigh += 7;

			else

				rlow -= 7;

			}

		// "Randomly" insert target strings that are not complete

		richText->InsertL(rlow, _L("TARGE"));

		richText->InsertL(rhigh - 1, _L("TARGE"));

		test(!richText->ParseText(startTags, lengthTags, EFalse));

		test(!richText->ParseText(startTags, lengthTags, ETrue));

		// Complete target string and check we find single target where we expect

		richText->InsertL(rlow + 5, 'T');

		richText->InsertL(rhigh + 5, 'T');

#if 1

		test(richText->ParseText(startTags, lengthTags, EFalse));

#else

		TBool bb = richText->ParseText(startTags, lengthTags, EFalse);

		test(bb);

#endif

		test((startTags == rlow) && (lengthTags == rhigh + 6 - rlow));

		test(richText->ParseText(startTags, lengthTags, ETrue));

		test((startTags == rlow) && (lengthTags == rhigh + 6 - rlow));

		// Completely remove target string

		richText->DeleteL(rhigh, 6);

		richText->DeleteL(rlow, 6);

		test(!richText->ParseText(startTags, lengthTags, EFalse));

		test(!richText->ParseText(startTags, lengthTags, ETrue));

		}

	// Clean up

	delete richText;

	delete GlobalCharFormatLayer;

	delete GlobalParaFormatLayer;

	CRichText::DeactivateParser(parser1);

	delete parser1;

	CRichText::DeactivateParserDefaults();

	delete editObserver;

	}

/**

@SYMTestCaseID          SYSLIB-ETEXT-UT-3405

@SYMTestCaseDesc	    Test for the fix for when CRichText crashes when parsers are active

@SYMTestPriority 	    Medium

@SYMTestActions  	    Calls PositionOfNextTag on all available document positions to validate fix.

@SYMTestExpectedResults Test must be able to call PositionOfNextTag on all document positions

@SYMDEF                 PDEF102494

*/	

void Test6()

	{

	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-UT-3405 Calling PositionOfNextTag on an empty document "));

	// Create and activate a parser

	CTestParser* parser1 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);

	// Create a CRichText

	CParaFormatLayer* GlobalParaFormatLayer = CParaFormatLayer::NewL();

	CCharFormatLayer* GlobalCharFormatLayer = CCharFormatLayer::NewL();

	CRichText* richText = CRichText::NewL(GlobalParaFormatLayer, GlobalCharFormatLayer, CEditableText::ESegmentedStorage, CEditableText::EDefaultTextGranularity);

	richText->SetPictureFactory(NULL, NULL);  // forces index generation

	// Switch on parsers for this CRichText

	CEditObserver* editObserver = new (ELeave) CEditObserver;

	richText->SetEditObserver(editObserver);

	//insert and format some text

	richText->InsertL(richText->DocumentLength(), _L("abcdTARGET"));

	TCharFormat charFormat;

	TCharFormatMask charFormatMask;

	richText->ApplyCharFormatL(charFormat, charFormatMask, 0, richText->DocumentLength());

	TInt startTags;

	TInt lengthTags;

	richText->ParseText(startTags, lengthTags, ETrue);

    // Call position of next tag on all document positions

	for (TInt i = 0; i <= richText->DocumentLength(); i++)

		{

		richText->PositionOfNextTag(i, parser1);

		}

	// Clean up

	delete richText;

	delete GlobalCharFormatLayer;

	delete GlobalParaFormatLayer;

	CRichText::DeactivateParser(parser1);

	delete parser1;

	CRichText::DeactivateParserDefaults();

	delete editObserver;

	}

/**

@SYMTestCaseID          SYSLIB-ETEXT-UT-3406

@SYMTestCaseDesc	    Test for the fix for when CRichText crashes when parsers are active

@SYMTestPriority 	    Medium

@SYMTestActions  	    Initialize two parsers. First parser has a target string of "TARGET",

                        and the second parser has a target string of "ARG". By parsing the

                        two overlapping (ARG is contained in TARGET) target strings, the changes

						for this defect have full coverage.

@SYMTestExpectedResults Test must be able to call PositionOfNextTag on the end of document positions

@SYMDEF                 PDEF102494

*/

void Test7()

	{

	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-UT-3406 Testing EText behaviour with active parsers and single target "));

	// Create and activate a parser

	CTestParser* parser1 = CTestParser::NewL();

	CRichText::ActivateParserL(parser1);

	CTestParser2* parser2 = CTestParser2::NewL();

	CRichText::ActivateParserL(parser2);

	// Create a CRichText

	CParaFormatLayer* GlobalParaFormatLayer = CParaFormatLayer::NewL();

	CCharFormatLayer* GlobalCharFormatLayer = CCharFormatLayer::NewL();

	CRichText* richText = CRichText::NewL(GlobalParaFormatLayer, GlobalCharFormatLayer, CEditableText::ESegmentedStorage, CEditableText::EDefaultTextGranularity);

	richText->SetPictureFactory(NULL, NULL);  // forces index generation

	// Switch on parsers for this CRichText

	CEditObserver* editObserver = new (ELeave) CEditObserver;

	richText->SetEditObserver(editObserver);

	// Insert 1000 chars (repeated string)

	TInt i;

	for (i = 0; i < 100; i++)

		richText->InsertL(richText->DocumentLength(), _L("abcdefghij"));

	TInt startTags;

	TInt lengthTags;

	TInt startPosition = 0;

	// Run test twice, once at start of string, once at end.

	for (TInt i=0;i < 2;i++)

		{

		//Insert target string that is not complete (for code coverage purposes).

		richText->InsertL(startPosition, _L("TARGE"));

		// Parse range provided only. Parser two will set it's parser tags on "ARG".

		test(richText->ParseText(startTags, lengthTags, EFalse));

		// Ensure this call does not fail at end of document (anymore). This gets

		// the position of the next tag at the end of document position. Should

		// be none found at end of document.

		test((richText->PositionOfNextTag(richText->DocumentLength(), parser1)) == -1);

		// Parse all text (for coverage purposes). This will first clear all tags,

		// and then re-applies the tags again on "ARG"

		test(richText->ParseText(startTags, lengthTags, ETrue));

		test((richText->PositionOfNextTag(richText->DocumentLength(), parser1)) == -1);

		// Complete target string. The purpose of completing the target string

		// here is for code coverage. The text has changed and the code path in 

		// parselst.cpp will change.

		richText->InsertL(startPosition + 5, 'T');

		// Parse range provided only. The tags on "ARG" are considered

		// lower precendence, so this will clear the parser tags on "ARG" and 

		// will apply the parser tags on "TARGET". 

		test(richText->ParseText(startTags, lengthTags, EFalse));

		test((richText->PositionOfNextTag(richText->DocumentLength(), parser1)) == -1);

		// Completely remove target string

		richText->DeleteL(startPosition, 6);

		test(!richText->ParseText(startTags, lengthTags, EFalse));

		test(!richText->ParseText(startTags, lengthTags, ETrue));

		startPosition = richText->DocumentLength();

		}

	// Clean up

	delete richText;

	delete GlobalCharFormatLayer;

	delete GlobalParaFormatLayer;

	CRichText::DeactivateParser(parser1);

	delete parser1;

	CRichText::DeactivateParser(parser2);

	delete parser2;

	CRichText::DeactivateParserDefaults();

	delete editObserver;

	}

CT_PARSE::CT_PARSE()

    {

    SetTestStepName(KTestStep_T_PARSE);

    pTestStep = this;

    }

TVerdict CT_PARSE::doTestStepL()

    {

    SetTestStepResult(EFail);

    TrapCleanup = CTrapCleanup::New();

    TRAPD(r,\

        {\

        for (TInt i=KTestCleanupStack;i>0;i--)\

            CleanupStack::PushL((TAny*)1);\

        test(r==KErrNone);\

        CleanupStack::Pop(KTestCleanupStack);\

        });

    INFO_PRINTF1(_L("Testing EText parser system"));

    INFO_PRINTF1(_L("Testing memory under normal conditions"));

    __UHEAP_MARK;

    TRAPD(ret1, Test1());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret2, Test2());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret3, Test3());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret4, Test4());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret5, Test5());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret6, Test6());

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAPD(ret7, Test7());

    __UHEAP_MARKEND;

    delete TrapCleanup;

    if (r == KErrNone && ret1 == KErrNone && ret2 == KErrNone && ret3 == KErrNone && ret4 == KErrNone && ret5 == KErrNone && ret6 == KErrNone && ret7 == KErrNone)

        {

        SetTestStepResult(EPass);

        }

    return TestStepResult();

    }