/*

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

*

*/

#include <txtetext.h>

#include "T_CPLAIN.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

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

const TBool KPictureIsDelimiter=EFalse;

const TBool KPunctuationIsDelimiter=ETrue;

template<class S,class T,CEditableText::TDocumentStorage D>

class TestCPlainText : public CPlainText

	{

public:

	static TestCPlainText* NewL();

	void TestL();  // Controls testing of the Flat storage usage.

	void TestSegmentedL();  // Controls testing of the segmented storage usage.

	void CheckDocLength(TInt aLength);

	void CheckDocLength(CPlainText* aDocument,TInt aLength);

	void CheckContent(const TDesC& aOriginal,TPtrC& aControl);

	void CheckContent(const TDesC& aOriginal,TDes& aControl);

	void CheckContent(CPlainText* aDocument,TPtrC& aControl);

	void CheckParagraphStart(TInt aCalculated,TInt aExpected);

	void CheckCharsSkipped(TInt aCalculated,TInt aExpected);

	void DoParagraphStart(TInt aStartPos,TInt aLength,CPlainText* aDocument);

	void InsertL(TInt aPos,const TDesC& aBuf);

	void CPlainTest0L();  // Checks all methods are present.

	void CPlainTest1L();  // Test construction under different memory conditions.

	void CPlainTest2L();  // Read method tests

	void CPlainTest3L();

	void CPlainTest4L();  

	void CPlainTest5L();

	void CPlainTest5aL();  // Added to test the word info method.

	void CPlainTest5bL();  // Added to test the CharPosOfParagraph method.

	void CPlainTest5cL();  // Added to test the ParagraphNumberForPos method.

	void DoCharPosOfParagraph(CPlainText* aText,TInt aParaN,TInt aPosCheck,TInt aLengthCheck);

	void DoParagraphNumberForPos(CPlainText* aText,TInt aPos,TInt aParaCheck,TInt aPosCheck);

	void CPlainTest6L();

	void CPlainTest7L();

	void CPlainTest8L();

	void DefectsL();

	void INC070807L();

private:

	TestCPlainText();

	TestCPlainText(const TestCPlainText& aTestCPlainText);

	TestCPlainText& operator=(const TestCPlainText& aTestCPlainText);

private:

	static TPtrC iDefaultDoc;

	static TPtrC iInBuf;

	static TPtrC iOutBuf;

	static TPtrC iOutBufComp;

	static TPtrC iInBuf2;

	static TPtrC iOutBuf2;

	static TPtrC iDummy;

	static TPtrC iComp1;

	static TPtrC iComp2;

	static TPtrC iComp3;

	static TPtrC iComp4;

	static TPtrC iComp5;

	static TPtrC iInsertBuf;

	static TPtrC iTestBuf1;

	static TPtrC iTestBuf2;

	static TPtrC iTestBuf2a;	

	static TPtrC iTestBuf3;

	};

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iDefaultDoc(_L("A default constructor has been used to build this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iComp1(_L("A default constructor has been used to build this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iComp2(_L("this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iComp3(_L("d."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iComp4(_L("."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iComp5(_L(""));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iDummy(_L("a"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iInBuf(_L("AAAAAAAAAA"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iOutBuf(_L(""));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iInBuf2(_L("OOOO"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iOutBufComp(_L("AAAAAAAAAA"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iOutBuf2(_L(""));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iTestBuf1(_L("abcdefINLINE_TEXTghijklmnopqrstuvwxyz"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iInsertBuf(_L("abcdefghijklmnopqrstuvwxyz"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iTestBuf2(_L("klmnopqrstuvwxyz"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iTestBuf2a(_L("klmnopqrst"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>::iTestBuf3(_L("efghi"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iDefaultDoc(_L("A default constructor has been used to build this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iComp1(_L("A default constructor has been used to build this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iComp2(_L("this text in a new document that is newly created."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iComp3(_L("d."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iComp4(_L("."));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iComp5(_L(""));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iDummy(_L("a"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iInBuf(_L("AAAAAAAAAA"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iOutBuf(_L(""));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iInBuf2(_L("OOOO"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iOutBufComp(_L("AAAAAAAAAA"));

template<> TPtrC TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>::iOutBuf2(_L(""));

#if ((defined (__GCC32__)) && (!defined (__X86GCC__)) )

template class TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage>;

template class TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage>;

#endif

template<class S, class T,CEditableText::TDocumentStorage D>

TestCPlainText<S,T,D>* TestCPlainText<S,T,D>::NewL()

//

//

//

	{

	TestCPlainText<S,T,D>* tmp=new(ELeave)TestCPlainText<S,T,D>;

	tmp->ConstructL(D);

	return tmp;

	}

template<class S, class T,CEditableText::TDocumentStorage D>

TestCPlainText<S,T,D>::TestCPlainText()

//

// Default constructor.

//

	{}

template<class S, class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckDocLength(TInt aLength)

//

// Test the current document length == aLength

//

	{

	TInt docLength=DocumentLength();

	test(docLength==aLength);

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckDocLength(CPlainText* aDocument,TInt aLength)

//

// Test that the length of document aDocument==aLength

//

	{

	test(aDocument->DocumentLength()==aLength);	

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckContent(const TDesC& aOriginal,TPtrC& aControl)

//

// Check that document content is what you expect

//

	{

	test(aOriginal.Length()==aControl.Length());

	for (TInt offset=0;offset<aOriginal.Length();offset++)

		{

		test(aOriginal[offset]==aControl[offset]);

		}

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckContent(const TDesC& aOriginal,TDes& aControl)

//

// Check that document content is what you expect

//

	{

	test(aOriginal.Length()==aControl.Length());

	for (TInt offset=0;offset<aOriginal.Length();offset++)

		{

		test(*aOriginal.Ptr()==*aControl.Ptr());

		}

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckContent(CPlainText* aDocument,TPtrC& aControl)

//

// Check that document content is what you expect

//

	{

	test(aDocument->DocumentLength()==aControl.Length());

	TPtrC view(iDummy);

	for (TInt offset=0;offset<aDocument->DocumentLength();offset++)

		{

		view.Set(aDocument->Read(offset).Ptr(),aDocument->Read(offset).Length());

		test(*view.Ptr()==aControl[offset]);

		}

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckParagraphStart(TInt aCalculated,TInt aExpected)

//

// Checks the value returned from ParagraphStart(aPos) is what

// it is expected to be.

//

	{

	test(aCalculated==aExpected);

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CheckCharsSkipped(TInt aCalculated,TInt aExpected)

//

// Check the number of characters skipped following a  ParagraphStart()

// is as expected.

//

	{

	test(aCalculated==aExpected);

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::InsertL(TInt aPos,const TDesC& aBuf)

//

	{CPlainText::InsertL(aPos,aBuf);}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::DoParagraphStart(TInt aStartPos,TInt aLength,CPlainText* aDocument)

//

// Parametric testing of the ParagraphStart method of the

// document class hierarchy.

//

	{

	TInt tempPos=0;

	TInt charsSkipped=0;

	for (TInt charPos=aStartPos;charPos<aStartPos+aLength;charPos++)

		{// Check Paragraph

		tempPos=charPos;

		charsSkipped=aDocument->ToParagraphStart(charPos);

		// charPos is updated to paragraph start character position.

		CheckParagraphStart(charPos,aStartPos);

		charPos=tempPos;  // Reset charPos following it's update.

		CheckCharsSkipped(charsSkipped,charPos-aStartPos);

		}

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest0L()

//

// Tests that all published methods exist.

//

	{

	__UHEAP_MARK;

	CPlainText* doc=CPlainText::NewL(D);

	doc->DocumentLength();

	doc->InsertL(0,iDefaultDoc);

	TChar character('X');

	doc->InsertL(0,character);

	TInt pos=3;

	doc->ToParagraphStart(pos);

	doc->DeleteL(3,1);

	doc->Read(2);

	doc->Read(2,2);

	TBuf<128> buf;

	doc->Extract(buf);

	TInt startPos,length;

	doc->GetWordInfo(13,startPos,length,KPictureIsDelimiter,KPunctuationIsDelimiter);

	doc->WordCount();

	doc->ParagraphCount();

	doc->Reset();

	delete doc;

	__UHEAP_MARKEND;

	}

template<class S, class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest1L()

//

// PlainText document construction.

//

	{

	__UHEAP_MARK;

	test(iByteStore!=NULL);

	CheckDocLength(0);

   	INFO_PRINTF1(_L("NewL()"));

  	CPlainText* document=CPlainText::NewL(D);

	document->InsertL(0,iDefaultDoc);

	test(document->DocumentLength()==95);

	delete document;

#ifdef _DEBUG

  	INFO_PRINTF1(_L("NewL() failing on OOM"));

	TInt flag=0;

	__UHEAP_FAILNEXT(1);

	TRAPD(ret, (void)CPlainText::NewL(D));

	if (ret!=KErrNone)

		{

		flag++;

		}

	// seems __UHEAP_FAILNEXT does not work well in platsim.

	// below test does not pass in platsim.

//	test(flag!=0);

#endif

	__UHEAP_MARKEND;

	}

template<class S, class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest2L()

//

// Tests the Read method.

// Does alter the state of the object.

//

	{

	__UHEAP_MARK;

	CPlainText* document=CPlainText::NewL(D);

	document->InsertL(0,iDefaultDoc);

	INFO_PRINTF1(_L("sense from start"));

	/*TPtrC dummy=*/document->Read(0);

	CheckDocLength(document,95);

	CheckContent(document,iComp1);

	INFO_PRINTF1(_L("sense from n"));

	TPtrC dummy2=document->Read(45);

	//iDummy.Set(document->Read(45).Ptr(),document->Read(45).Length());

	CPlainText* doc2=CPlainText::NewL(D);

	doc2->InsertL(0,dummy2);

	doc2->DeleteL(50,1);  // We need a debug copy constructor here.  The origianl

		// document has an oed character, and when we construct a new doucment

		// based on the original, we get our own eod character plus the one that is

		// part of the original, = 2 eod characters.

		// This breaks the following tests.  So in the short term I have elected to delete this

		// trailing, unwanted eod character.

	CheckDocLength(doc2,50);

	CheckContent(doc2,iComp2);

	delete doc2;

	INFO_PRINTF1(_L("sense from last-1"));

	iDummy.Set(document->Read(93).Ptr(),document->Read(93).Length());

	CPlainText* doc3=CPlainText::NewL(D);

	doc3->InsertL(0,iDummy);

	doc3->DeleteL(2,1);

	CheckDocLength(doc3,2);

	CheckContent(doc3,iComp3);

	delete doc3;

	INFO_PRINTF1(_L("sense from last"));

	iDummy.Set(document->Read(94).Ptr(),document->Read(94).Length());

	CPlainText* doc4=CPlainText::NewL(D);

	doc4->InsertL(0,iDummy);

	doc4->DeleteL(1,1);

	CheckDocLength(doc4,1);

	CheckContent(doc4,iComp4);

	delete doc4;

	INFO_PRINTF1(_L("sense from last+1"));

	iDummy.Set(document->Read(95).Ptr(),document->Read(95).Length());

	CPlainText* doc5=CPlainText::NewL(D);

	doc5->InsertL(0,iDummy);

	doc5->DeleteL(0,1);

	CheckDocLength(doc5,0);

	CheckContent(doc5,iComp5);

	delete doc5;

	delete document;

	__UHEAP_MARKEND;

	}

template<class S, class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest3L()

//

// Tests correct execution of insert and delete

// on default document content.  The document

// content should be left unchanged.

//

	{

	__UHEAP_MARK;

	// Create document with 'AAAAAAAAAA'

	TChar character('Y');

	CPlainText* document=CPlainText::NewL(D);

	document->InsertL(0,iInBuf);

	iOutBuf.Set(document->Read(0));

	CheckDocLength(document,10);

	CheckContent(document,iOutBufComp);

	INFO_PRINTF1(_L("Inverting at start"));

	document->InsertL(0,iInBuf2);

	document->InsertL(0,character);

	document->DeleteL(0,1);

	CheckDocLength(document,14);

	document->DeleteL(0,4);

 	iOutBuf2.Set(document->Read(0));

	CheckDocLength(document,10);

	CheckContent(document,iOutBufComp);

	INFO_PRINTF1(_L("Inverting in middle"));

	document->InsertL(4,iInBuf2);

	document->InsertL(5,character);

	document->DeleteL(5,1);

	CheckDocLength(document,14);

	document->DeleteL(4,4);

	iOutBuf2.Set(document->Read(0));

	CheckDocLength(document,10);

	CheckContent(document,iOutBufComp);

	INFO_PRINTF1(_L("Inverting at end"));	

	document->InsertL(10,iInBuf2);

	document->InsertL(11,character);

	document->DeleteL(11,1);

	CheckDocLength(document,14);

	document->DeleteL(10,4);

	iOutBuf2.Set(document->Read(0));

	CheckDocLength(document,10);

	CheckContent(document,iOutBufComp);

	document->DeleteL(0,10);

	CheckDocLength(0);

	delete document;

	__UHEAP_MARKEND;

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest4L()

//

// Test scan method combinations

//

	{

	// Create document content for test.

	TBuf<128> content;

	content.Append(_L("Paragraph one. Complete with sentence and word breaks."));

	content.Append(EParagraphDelimiter);

	// Para 1 is 55 characters incl. delimiter.

	content.Append(_L("This is paragraph two."));

	content.Append(EParagraphDelimiter);

	// Para 2 is 23 characters incl. delimiter.

	content.Append(_L("This is paragraph 3"));

	content.Append(EParagraphDelimiter);

	// Para 3 is 20 characters incl. delimiter.

	content.Append(EParagraphDelimiter);

	// Para 4 is 1 character incl. delimiter.

	content.Append(EParagraphDelimiter);

	content.Append(EParagraphDelimiter);

	// Create document.

	CPlainText* document=CPlainText::NewL(D);

	TPtrC body(content);

	document->InsertL(0,body);

	// Now do the tests.

	INFO_PRINTF1(_L("Paragraph 1"));

	DoParagraphStart(0,55,document);  // Paragraph 1

	INFO_PRINTF1(_L("Paragraph 2"));

	DoParagraphStart(55,23,document);  // Paragraph 2

	INFO_PRINTF1(_L("Paragraph 3"));

	DoParagraphStart(78,20,document);  // Paragraph 3

	INFO_PRINTF1(_L("Paragraph 4->2 consecutive delimiters, posshould not change"));

	DoParagraphStart(99,1,document);  // Paragraph 6

	delete document;

	}

template<class S,class T,CEditableText::TDocumentStorage D>

void TestCPlainText<S,T,D>::CPlainTest5L()

//

// Tests the extract method.

//

	{

	__UHEAP_MARK;

	CPlainText* doc=CPlainText::NewL(D);

	doc->InsertL(0,iDefaultDoc);

	INFO_PRINTF1(_L("Extract(buf)"));

	TBuf<128> buf;

	doc->Extract(buf);

	CheckContent(iDefaultDoc,buf);

	INFO_PRINTF1(_L("Extract(buf,pos)"));

	TInt pos=45;

	doc->Extract(buf,pos);

	CheckContent(iComp2,buf);

	INFO_PRINTF1(_L("Extract(buf) from multiple segments"));

	TBuf<256> bigBuf(_L("abcdefghijklmnopqrstuvwxyzABCEDFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCEDFGHIJKLMNOPQRSTUVWXYZ"));

	CPlainText* segDoc=CPlainText::NewL(ESegmentedStorage);

	segDoc->InsertL(0,bigBuf);

	segDoc->Extract(buf);

	CheckContent(bigBuf,buf);

	delete segDoc;

	delete doc;

	__UHEAP_MARKEND;

	}

template<class S,class T,CEditableText::TDocumentStorage D>