/*

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

* TPARSE.CPP

*

*/

#include <e32test.h>

#include <txtrich.h>

#include <e32math.h>

#include "T_parse.h"

LOCAL_D CTrapCleanup* TrapCleanup;

LOCAL_D RTest test(_L("Testing EText parser system"));

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()

	{

	test.Next(_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()

	{

	test.Next(_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()

	{

	test.Next(_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;

		}

	test.Printf(_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

	test.Next(_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++)