Symaptic: os/textandloc/textrendering/texthandling/ttext/T

     1 /*

     2 * Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <txtetext.h>

    20 #include "T_CPLAIN.h"

    22 LOCAL_D CTestStep *pTestStep = NULL;

    23 #define test(cond)											\

    24 	{														\

    25 	TBool __bb = (cond);									\

    26 	pTestStep->TEST(__bb);									\

    27 	if (!__bb)												\

    28 		{													\

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

    30 		User::Leave(1);										\

    31 		}													\

    32 	}

    33 #undef INFO_PRINTF1

    34 #undef INFO_PRINTF2

    35 // copy from tefexportconst.h

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

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

    39 const TBool KPictureIsDelimiter=EFalse;

    40 const TBool KPunctuationIsDelimiter=ETrue;

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

    43 class TestCPlainText : public CPlainText

    44 	{

    45 public:

    46 	static TestCPlainText* NewL();

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

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

    49 	void CheckDocLength(TInt aLength);

    50 	void CheckDocLength(CPlainText* aDocument,TInt aLength);

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

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

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

    54 	void CheckParagraphStart(TInt aCalculated,TInt aExpected);

    55 	void CheckCharsSkipped(TInt aCalculated,TInt aExpected);

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

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

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

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

    60 	void CPlainTest2L();  // Read method tests

    61 	void CPlainTest3L();

    62 	void CPlainTest4L();

    63 	void CPlainTest5L();

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

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

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

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

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

    69 	void CPlainTest6L();

    70 	void CPlainTest7L();

    71 	void CPlainTest8L();

    72 	void DefectsL();

    73 	void INC070807L();

    74 private:

    75 	TestCPlainText();

    76 	TestCPlainText(const TestCPlainText& aTestCPlainText);

    77 	TestCPlainText& operator=(const TestCPlainText& aTestCPlainText);

    78 private:

    79 	static TPtrC iDefaultDoc;

    80 	static TPtrC iInBuf;

    81 	static TPtrC iOutBuf;

    82 	static TPtrC iOutBufComp;

    83 	static TPtrC iInBuf2;

    84 	static TPtrC iOutBuf2;

    85 	static TPtrC iDummy;

    86 	static TPtrC iComp1;

    87 	static TPtrC iComp2;

    88 	static TPtrC iComp3;

    89 	static TPtrC iComp4;

    90 	static TPtrC iComp5;

    91 	static TPtrC iInsertBuf;

    92 	static TPtrC iTestBuf1;

    93 	static TPtrC iTestBuf2;

    94 	static TPtrC iTestBuf2a;

    95 	static TPtrC iTestBuf3;

    96 	};

    98 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."));

    99 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."));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   116 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."));

   117 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."));

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

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

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

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

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

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

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

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

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

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

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

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

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

   132 #endif

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

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

   137 //

   138 //

   139 //

   140 	{

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

   142 	tmp->ConstructL(D);

   143 	return tmp;

   144 	}

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

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

   149 //

   150 // Default constructor.

   151 //

   152 	{}

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

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

   157 //

   158 // Test the current document length == aLength

   159 //

   160 	{

   161 	TInt docLength=DocumentLength();

   162 	test(docLength==aLength);

   163 	}

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

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

   168 //

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

   170 //

   171 	{

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

   173 	}

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

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

   178 //

   179 // Check that document content is what you expect

   180 //

   181 	{

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

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

   184 		{

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

   186 		}

   187 	}

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

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

   192 //

   193 // Check that document content is what you expect

   194 //

   195 	{

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

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

   198 		{

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

   200 		}

   201 	}

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

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

   207 //

   208 // Check that document content is what you expect

   209 //

   210 	{

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

   212 	TPtrC view(iDummy);

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

   214 		{

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

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

   217 		}

   218 	}

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

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

   223 //

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

   225 // it is expected to be.

   226 //

   227 	{

   228 	test(aCalculated==aExpected);

   229 	}

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

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

   234 //

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

   236 // is as expected.

   237 //

   238 	{

   239 	test(aCalculated==aExpected);

   240 	}

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

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

   245 //

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

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

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

   252 //

   253 // Parametric testing of the ParagraphStart method of the

   254 // document class hierarchy.

   255 //

   256 	{

   257 	TInt tempPos=0;

   258 	TInt charsSkipped=0;

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

   260 		{// Check Paragraph

   261 		tempPos=charPos;

   262 		charsSkipped=aDocument->ToParagraphStart(charPos);

   263 		// charPos is updated to paragraph start character position.

   264 		CheckParagraphStart(charPos,aStartPos);

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

   266 		CheckCharsSkipped(charsSkipped,charPos-aStartPos);

   267 		}

   268 	}

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

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

   273 //

   274 // Tests that all published methods exist.

   275 //

   276 	{

   277 	__UHEAP_MARK;

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

   279 	doc->DocumentLength();

   280 	doc->InsertL(0,iDefaultDoc);

   281 	TChar character('X');

   282 	doc->InsertL(0,character);

   283 	TInt pos=3;

   284 	doc->ToParagraphStart(pos);

   285 	doc->DeleteL(3,1);

   286 	doc->Read(2);

   287 	doc->Read(2,2);

   288 	TBuf<128> buf;

   289 	doc->Extract(buf);

   290 	TInt startPos,length;

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

   292 	doc->WordCount();

   293 	doc->ParagraphCount();

   294 	doc->Reset();

   295 	delete doc;

   296 	__UHEAP_MARKEND;

   297 	}

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

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

   302 //

   303 // PlainText document construction.

   304 //

   305 	{

   306 	__UHEAP_MARK;

   307 	test(iByteStore!=NULL);

   308 	CheckDocLength(0);

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

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

   312 	document->InsertL(0,iDefaultDoc);

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

   314 	delete document;

   315 #ifdef _DEBUG

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

   317 	TInt flag=0;

   318 	__UHEAP_FAILNEXT(1);

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

   320 	if (ret!=KErrNone)

   321 		{

   322 		flag++;

   323 		}

   324 	// seems __UHEAP_FAILNEXT does not work well in platsim.

   325 	// below test does not pass in platsim.

   326 //	test(flag!=0);

   327 #endif

   329 	__UHEAP_MARKEND;

   330 	}

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

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

   335 //

   336 // Tests the Read method.

   337 // Does alter the state of the object.

   338 //

   339 	{

   340 	__UHEAP_MARK;

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

   342 	document->InsertL(0,iDefaultDoc);

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

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

   346 	CheckDocLength(document,95);

   347 	CheckContent(document,iComp1);

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

   350 	TPtrC dummy2=document->Read(45);

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

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

   353 	doc2->InsertL(0,dummy2);

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

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

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

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

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

   359 		// trailing, unwanted eod character.

   360 	CheckDocLength(doc2,50);

   361 	CheckContent(doc2,iComp2);

   362 	delete doc2;

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

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

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

   367 	doc3->InsertL(0,iDummy);

   368 	doc3->DeleteL(2,1);

   369 	CheckDocLength(doc3,2);

   370 	CheckContent(doc3,iComp3);

   371 	delete doc3;

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

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

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

   376 	doc4->InsertL(0,iDummy);

   377 	doc4->DeleteL(1,1);

   378 	CheckDocLength(doc4,1);

   379 	CheckContent(doc4,iComp4);

   380 	delete doc4;

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

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

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

   385 	doc5->InsertL(0,iDummy);

   386 	doc5->DeleteL(0,1);

   387 	CheckDocLength(doc5,0);

   388 	CheckContent(doc5,iComp5);

   389 	delete doc5;

   391 	delete document;

   392 	__UHEAP_MARKEND;

   393 	}

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

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

   398 //

   399 // Tests correct execution of insert and delete

   400 // on default document content.  The document

   401 // content should be left unchanged.

   402 //

   403 	{

   404 	__UHEAP_MARK;

   405 	// Create document with 'AAAAAAAAAA'

   406 	TChar character('Y');

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

   408 	document->InsertL(0,iInBuf);

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

   410 	CheckDocLength(document,10);

   411 	CheckContent(document,iOutBufComp);

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

   414 	document->InsertL(0,iInBuf2);

   415 	document->InsertL(0,character);

   416 	document->DeleteL(0,1);

   417 	CheckDocLength(document,14);

   418 	document->DeleteL(0,4);

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

   420 	CheckDocLength(document,10);

   421 	CheckContent(document,iOutBufComp);

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

   424 	document->InsertL(4,iInBuf2);

   425 	document->InsertL(5,character);

   426 	document->DeleteL(5,1);

   427 	CheckDocLength(document,14);

   428 	document->DeleteL(4,4);

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

   430 	CheckDocLength(document,10);

   431 	CheckContent(document,iOutBufComp);

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

   434 	document->InsertL(10,iInBuf2);

   435 	document->InsertL(11,character);

   436 	document->DeleteL(11,1);

   437 	CheckDocLength(document,14);

   438 	document->DeleteL(10,4);

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

   440 	CheckDocLength(document,10);

   441 	CheckContent(document,iOutBufComp);

   443 	document->DeleteL(0,10);

   444 	CheckDocLength(0);

   445 	delete document;

   447 	__UHEAP_MARKEND;

   448 	}

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

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

   453 //

   454 // Test scan method combinations

   455 //

   456 	{

   457 	// Create document content for test.

   458 	TBuf<128> content;

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

   460 	content.Append(EParagraphDelimiter);

   461 	// Para 1 is 55 characters incl. delimiter.

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

   463 	content.Append(EParagraphDelimiter);

   464 	// Para 2 is 23 characters incl. delimiter.

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

   466 	content.Append(EParagraphDelimiter);

   467 	// Para 3 is 20 characters incl. delimiter.

   468 	content.Append(EParagraphDelimiter);

   469 	// Para 4 is 1 character incl. delimiter.

   470 	content.Append(EParagraphDelimiter);

   471 	content.Append(EParagraphDelimiter);

   472 	// Create document.

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

   474 	TPtrC body(content);

   475 	document->InsertL(0,body);

   476 	// Now do the tests.

   477 	INFO_PRINTF1(_L("Paragraph 1"));

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

   479 	INFO_PRINTF1(_L("Paragraph 2"));

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

   481 	INFO_PRINTF1(_L("Paragraph 3"));

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

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

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

   486 	delete document;

   487 	}

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

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

   492 //

   493 // Tests the extract method.

   494 //

   495 	{

   496 	__UHEAP_MARK;

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

   498 	doc->InsertL(0,iDefaultDoc);

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

   501 	TBuf<128> buf;

   502 	doc->Extract(buf);

   503 	CheckContent(iDefaultDoc,buf);

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

   506 	TInt pos=45;

   507 	doc->Extract(buf,pos);

   508 	CheckContent(iComp2,buf);

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

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

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

   513 	segDoc->InsertL(0,bigBuf);

   514 	segDoc->Extract(buf);

   515 	CheckContent(bigBuf,buf);

   516 	delete segDoc;

   518 	delete doc;

   519 	__UHEAP_MARKEND;

   520 	}

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

   524 void TestCPlainText<S,T,D>::CPlainTest5aL()

   525 //

   526 // Tests the WordInfo() method.

   527 //

   528 	{

   529 	__UHEAP_MARK;

   530 	TPtrC content(_L("   some   testing  a  texty     content"));

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

   533 	doc->InsertL(0,content);

   535 	INFO_PRINTF1(_L("WordInfo()"));

   536 	TInt currentPos,startPos,length;

   537 	currentPos=0;

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

   539 	test(startPos==0);	test(length==0);

   540 	currentPos=1;

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

   542 	test(startPos==1);	test(length==0);

   543 	currentPos=2;

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

   545 	test(startPos==2);	test(length==0);

   547 	currentPos=3;

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

   549 	test(startPos==3);	test(length==4);

   551 	currentPos=5;

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

   553 	test(startPos==3);	test(length==4);

   555 	currentPos=7;

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

   557 	test(startPos==3);	test(length==4);

   559 	currentPos=8;

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

   561 	test(startPos==8);	test(length==0);

   563 	currentPos=9;

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

   565 	test(startPos==9);	test(length==0);

   567 	currentPos=10;

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

   569 	test(startPos==10);	test(length==7);

   571 	currentPos=18;

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

   573 	test(startPos==18);	test(length==0);

   575 	currentPos=19;

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

   577 	test(startPos==19);	test(length==1);

   579 	currentPos=20;

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

   581 	test(startPos==19);	test(length==1);

   583 	currentPos=21;

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

   585 	test(startPos==21);	test(length==0);

   587 	currentPos=38;

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

   589 	test(startPos=32);	test(length==7);

   591 	currentPos=39;

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

   593 	test(startPos=32);	test(length==7);

   595 	delete doc;

   596 	__UHEAP_MARKEND;

   597 	}

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

   601 void TestCPlainText<S,T,D>::CPlainTest5bL()

   602 //

   603 // Tests the CharPosOfParagraph() method.

   604 //

   605 	{

   606 	__UHEAP_MARK;

   607 	TPtrC para1(_L("para1"));

   608 	TPtrC para2(_L("para22"));

   609 	TPtrC para3(_L("para333"));

   610 	TPtrC para4(_L("para4444"));

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

   612 	doc->InsertL(0,para1);

   613 	TChar delim(EParagraphDelimiter);

   614 	doc->InsertL(5,delim);

   615 	doc->InsertL(6,para2);

   616 	doc->InsertL(12,delim);

   617 	doc->InsertL(13,para3);

   618 	doc->InsertL(20,delim);

   619 	doc->InsertL(21,para4);

   620 	//

   621 	TInt paraN=0;

   622 	//

   623 	DoCharPosOfParagraph(doc,paraN,0,6);

   624 	paraN++;

   625 	DoCharPosOfParagraph(doc,paraN,6,7);

   626 	paraN++;

   627 	DoCharPosOfParagraph(doc,paraN,13,8);

   628 	paraN++;

   629 	DoCharPosOfParagraph(doc,paraN,21,9);

   630 	paraN++;

   631 	DoCharPosOfParagraph(doc,paraN,CPlainText::EScanEndOfData,-1);

   632 	//

   633 	doc->InsertL(0,delim);

   634 	doc->InsertL(0,delim);

   635 	paraN=0;

   636 	DoCharPosOfParagraph(doc,paraN,0,1);

   637 	doc->InsertL(doc->DocumentLength(),delim);

   638 	// There are now 6 paras.

   639 	TInt paraCount=doc->ParagraphCount();

   640 	test(paraCount==7);

   641 	paraN=5;

   642 	DoCharPosOfParagraph(doc,paraN,23,9);

   643 	paraN++;

   644 	DoCharPosOfParagraph(doc,paraN,32,1);

   645 	delete doc;

   646 	__UHEAP_MARKEND;

   647 	}

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

   651 void TestCPlainText<S,T,D>::DoCharPosOfParagraph(CPlainText* aText,TInt aParaN,TInt aPosCheck,TInt aLengthCheck)

   652 //

   653 //

   654 //

   655 	{

   656 	TInt length=0;

   657 	TInt pos=-1;

   658 	pos=aText->CharPosOfParagraph(length,aParaN);

   659 	test(pos==aPosCheck);

   660 	if (aLengthCheck!=-1)

   661 		test(length==aLengthCheck);

   662 	}

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

   666 void TestCPlainText<S,T,D>::CPlainTest5cL()

   667 //

   668 // Tests the ParagraphNumberForPos() method.

   669 //

   670 	{

   671 	__UHEAP_MARK;

   672 	TPtrC para1(_L("para1"));

   673 	TPtrC para2(_L("para22"));

   674 	TPtrC para3(_L("para333"));

   675 	TPtrC para4(_L("para4444"));

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

   677 	doc->InsertL(0,para1);

   678 	TChar delim(EParagraphDelimiter);

   679 	doc->InsertL(5,delim);

   680 	doc->InsertL(6,para2);

   681 	doc->InsertL(12,delim);

   682 	doc->InsertL(13,para3);

   683 	doc->InsertL(20,delim);

   684 	doc->InsertL(21,para4);

   685 	//

   686 	TInt pos=0;

   687 	//

   688 	for (;pos<6;pos++)

   689 		DoParagraphNumberForPos(doc,pos,0,0);

   690 	for (pos=6;pos<13;pos++)

   691 		DoParagraphNumberForPos(doc,pos,1,6);

   692 	for (pos=13;pos<21;pos++)

   693 		DoParagraphNumberForPos(doc,pos,2,13);

   694 	for (pos=21;pos<30;pos++)

   695 		DoParagraphNumberForPos(doc,pos,3,21);

   696 	//

   697 	doc->InsertL(0,delim);

   698 	doc->InsertL(0,delim);

   699 	pos=0;

   700 	DoParagraphNumberForPos(doc,pos,0,0);

   701 	pos=1;

   702 	DoParagraphNumberForPos(doc,pos,1,1);

   703 	doc->InsertL(doc->DocumentLength(),delim);

   704 	// There are now 7 paras.

   705 	TInt paraCount=doc->ParagraphCount();

   706 	test(paraCount==7);

   707 	pos=32;

   708 	DoParagraphNumberForPos(doc,pos,6,32);

   709 	delete doc;

   710 	__UHEAP_MARKEND;

   711 	}

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

   715 void TestCPlainText<S,T,D>::DoParagraphNumberForPos(CPlainText* aText,TInt aPos,TInt aParaCheck,TInt aPosCheck)

   716 //

   717 //

   718 //

   719 	{

   720 	TInt para=-1;

   721 	para=aText->ParagraphNumberForPos(aPos);

   722 	test(para==aParaCheck);

   723 	test(aPos==aPosCheck);

   724 	}

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

   728 void TestCPlainText<S,T,D>::CPlainTest6L()

   729 //

   730 // Tests the word count method.

   731 //

   732 	{

   733 	__UHEAP_MARK;

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

   735 	TInt count=doc->WordCount();

   736 	test(count==0);

   738 	TPtrC buf(_L("This has four words"));

   739 	doc->InsertL(0,buf);

   740 	count=doc->WordCount();

   741 	test(count==4);

   742 	delete doc;

   743 	__UHEAP_MARKEND;

   744 	}

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

   748 void TestCPlainText<S,T,D>::CPlainTest7L()

   749 //

   750 // Tests the paragraph count method.

   751 //

   752 	{

   753 	__UHEAP_MARK;

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

   755 	TPtrC buf(_L("This has four words"));

   756 	doc->InsertL(0,buf);

   757 	TInt count=doc->ParagraphCount();

   758 	test(count==1);

   759 	delete doc;

   760 	__UHEAP_MARKEND;

   761 	}

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

   765 void TestCPlainText<S,T,D>::CPlainTest8L()

   766 //

   767 // Tests the reset method behave as specified.

   768 //

   769 	{

   770 	__UHEAP_MARK;

   771 	INFO_PRINTF1(_L("1st Reset"));

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

   773 	doc->InsertL(0,iDefaultDoc);

   774 	test(doc->DocumentLength()==95);

   775 	doc->Reset();

   776 	test(doc->DocumentLength()==0);

   778 	// Test multiple resets work.

   779 	// This defect was highlighted by DavidW 13.10.95.

   780 	// It arises because I have added an assert length>0 in the delete method.

   781 	// Clearly on a second reset the length is zero, hence the failure.

   782 	// Defect fixed 13.10.95 by DuncanS and included in the tests below.

   783 	INFO_PRINTF1(_L("2nd Reset - defect - DavidW 13.10.95"));

   784 	doc->Reset();

   786 	delete doc;

   787 	__UHEAP_MARKEND;

   788 	}

   790 /**

   791 @SYMTestCaseID          SYSLIB-ETEXT-UT-1574

   792 @SYMTestCaseDesc	    Tests for the removal of inline text when inline text removal flag is set.

   793 @SYMTestPriority 	    High

   794 @SYMTestActions  	    Inserts some inline text into a section of text, tests to make sure it was inserts

   795 						then it removes the inline text and tests to make sure it was all removed correctly.

   796 @SYMTestExpectedResults Test must not fail

   797 @SYMDEF                 INC070807

   798 */

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

   802 void TestCPlainText<S,T,D>::INC070807L()

   803 //

   804 // Tests whether inline text is removed when the EExcludeInlineEditedText flag is set.

   805 //

   806 	{

   807 	__UHEAP_MARK;

   809 	TInt textLengthFifty = 50;

   810 	TInt textLengthTen = 10;

   811 	TInt startingPositionZero = 0;

   812 	TInt startingPositionTen = 10;

   813 	TInt NumberDeleted, NumberInserted, PositionOfInsertion, NewPositionOfInsertion = 0;

   814 	TBool HasChangedFormat = NULL;

   815 	TInt NumberToHide = 0;

   816 	MFepInlineTextFormatRetriever* InlineTextFormatRetriever = NULL;

   817 	TBufC<20> InitialInlineText =_L("INLINE_TEXT");  // inline text to be inserted

   818 	TBuf<50> outputBuf;

   820 	INFO_PRINTF1(_L("Return all the text"));

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

   822 	doc->DocumentLength();

   823 	doc->InsertL(0,iInsertBuf); // insert "abcdefghijklmnopqrstuvwxyz"

   826 	TInt PosOfInlineText = 6;

   828 	doc->StartFepInlineEditL(HasChangedFormat,NumberDeleted,NumberInserted,PositionOfInsertion,NewPositionOfInsertion,InitialInlineText,PosOfInlineText,NumberToHide,*InlineTextFormatRetriever);

   830 	doc->Extract(outputBuf, startingPositionZero, textLengthFifty);  // Returns all the text

   831 	test (iTestBuf1 == outputBuf);  // testing outputBuf, making sure it contains the inline text - "abcdefINLINE_TEXTghijklmnopqrstuvwxyz"

   833 	INFO_PRINTF1(_L("Extract and discard only the inline text, from Pos0 returning the rest"));

   834 	doc->ExtractSelectively(outputBuf, startingPositionZero, textLengthFifty, EExcludeInlineEditedText); // Returns only non-inline text

   835 	test (iInsertBuf == outputBuf); // testing outputBuf, making sure the inline text has been extracted correctly - "abcdefghijklmnopqrstuvwxyz"

   836 	delete doc;

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

   840 	doc2->DocumentLength();

   841 	doc2->InsertL(0,iInsertBuf); // insert "abcdefghijklmnopqrstuvwxyz"

   843 	INFO_PRINTF1(_L("Extract upto 50 character, from Pos10, within the range (no inline editting set)"));

   844 	// Returns upto 50 characters starting from Pos10

   845 	doc2->ExtractSelectively(outputBuf, startingPositionTen, textLengthFifty, EExcludeInlineEditedText);

   846 	test (iTestBuf2 == outputBuf);  // "klmnopqrstuvwxyz"

   848 	INFO_PRINTF1(_L("Extract upto 10 characters, from Pos10, within the range (no inline editting set)"));

   849 	// Returns upto 10 characters starting from Pos10

   850 	doc2->ExtractSelectively(outputBuf, startingPositionTen, textLengthTen, EExcludeInlineEditedText);

   851 	test (iTestBuf2a == outputBuf); // "klmnopqrst"

   853 	INFO_PRINTF1(_L("Extract upto 50 character, from Pos0, 'EExtractAll' flag selected"));

   854 	// Returns upto 50 characters starting from Pos0.

   855 	doc2->ExtractSelectively(outputBuf, startingPositionZero, textLengthFifty, EExtractAll);

   856 	test (iInsertBuf == outputBuf); // "abcdefghijklmnopqrstuvwxyz"

   857 	delete doc2;

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

   861 	doc3->DocumentLength();

   862 	doc3->InsertL(0,iInsertBuf); // insert "abcdefghijklmnopqrstuvwxyz"

   864 	PosOfInlineText = 4;

   866 	doc3->StartFepInlineEditL(HasChangedFormat,NumberDeleted,NumberInserted,PositionOfInsertion,NewPositionOfInsertion,InitialInlineText,PosOfInlineText,NumberToHide,*InlineTextFormatRetriever);

   868 	INFO_PRINTF1(_L("Extract all the non-inline text, from Pos10, within the range (inline editting on)"));

   869 	doc3->ExtractSelectively(outputBuf, startingPositionTen, textLengthTen, EExcludeInlineEditedText); // Returns only non-inline text.

   870 	test (iTestBuf3 == outputBuf); // testing outputBuf, making sure the inline text has been extracted correctly	- "efghi".

   871 	delete doc3;

   873 	__UHEAP_MARKEND;

   874 	}

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

   878 void TestCPlainText<S,T,D>::TestSegmentedL()

   879 //

   880 // Controls testing of the segmented storage case.

   881 //

   882 	{

   883     INFO_PRINTF1(_L("All methods"));

   884 	CPlainTest0L();

   885 	INFO_PRINTF1(_L("Construction"));

   886 	CPlainTest1L();

   887 	INFO_PRINTF1(_L("Read"));

   888 	INFO_PRINTF1(_L("Not yet implemented"));

   890  	INFO_PRINTF1(_L("Inverse Testing using InsertL&Delete: content left intact"));

   891 	CPlainTest3L();

   892  	INFO_PRINTF1(_L("Paragraph Start"));

   893 	CPlainTest4L();

   894  	INFO_PRINTF1(_L("Extract"));

   895 	CPlainTest5L();

   896 	INFO_PRINTF1(_L("WordInfo"));

   897 	CPlainTest5aL();

   898 	INFO_PRINTF1(_L("CharPosOfParagraph"));

   899 	CPlainTest5bL();

   900 	INFO_PRINTF1(_L("ParagraphNumberForPos"));

   901 	CPlainTest5cL();

   902  	INFO_PRINTF1(_L("CountWords"));

   903 	CPlainTest6L();

   904 	INFO_PRINTF1(_L("CountParas"));

   905 	CPlainTest7L();

   906  	INFO_PRINTF1(_L("Reset"));

   907 	CPlainTest8L();

   908 	}

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

   913 void TestCPlainText<S,T,D>::TestL()

   914 //

   915 // Test the CPlainText methods

   916 //

   917 	{

   918 	INFO_PRINTF1(_L("All methods"));

   919 	CPlainTest0L();

   920 	INFO_PRINTF1(_L("Construction"));

   921 	CPlainTest1L();

   922 	INFO_PRINTF1(_L("Read"));

   923 	CPlainTest2L();

   924 	INFO_PRINTF1(_L("Inverse Testing using InsertL&Delete: content left intact"));

   925 	CPlainTest3L();

   926 	INFO_PRINTF1(_L("Paragraph Start"));

   927 	CPlainTest4L();

   928 	INFO_PRINTF1(_L("Extract"));

   929 	CPlainTest5L();

   930 	INFO_PRINTF1(_L("WordInfo"));

   931 	CPlainTest5aL();

   932 	INFO_PRINTF1(_L("CharPosOfParagraph"));

   933 	CPlainTest5bL();

   934 	INFO_PRINTF1(_L("ParagraphNumberForPos"));

   935 	CPlainTest5cL();

   936 	INFO_PRINTF1(_L("CountWords"));

   937 	CPlainTest6L();

   938 	INFO_PRINTF1(_L("CountParas"));

   939 	CPlainTest7L();

   940 	INFO_PRINTF1(_L("Reset"));

   941 	CPlainTest8L();

   942 	}

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

   947 void TestCPlainText<S,T,D>::DefectsL()

   948 //

   949 // Defect Fixes

   950 //

   951 	{

   952 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-UT-1574 INC070807 "));

   953 	INC070807L();

   954 	}

   956 CT_CPLAIN::CT_CPLAIN()

   957     {

   958     SetTestStepName(KTestStep_T_CPLAIN);

   959     pTestStep = this;

   960     }

   962 TVerdict CT_CPLAIN::doTestStepL()

   963     {

   964     SetTestStepResult(EFail);

   966     CTrapCleanup* cleanup=CTrapCleanup::New();

   968     __UHEAP_MARK;

   970     typedef TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage> instance1;

   971     typedef TestCPlainText<TText,TPtrC,CEditableText::ESegmentedStorage> instance2;

   972     typedef TestCPlainText<TText,TPtrC,CEditableText::EFlatStorage> instance3;

   974     instance1* doctest=NULL;

   976     TRAPD(ret1, doctest=instance1::NewL());

   978     INFO_PRINTF1(_L("CPlainText - Flat"));

   979     TRAPD(ret2, doctest->TestL());

   980     delete doctest;

   982     INFO_PRINTF1(_L("CPlainText - Segmented"));

   983     instance2* doctest1=NULL;

   984     TRAPD(ret3, doctest1=instance2::NewL());

   985     TRAPD(ret4, doctest1->TestSegmentedL());

   986     delete doctest1;

   988     INFO_PRINTF1(_L("Defect..."));

   989     instance3* doctest2=NULL;

   990     TRAPD(ret5, doctest2=instance3::NewL());

   991     TRAPD(ret6, doctest2->DefectsL());

   992     delete doctest2;

   994     __UHEAP_MARKEND;

   996     delete cleanup;

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

   999         {

  1000         SetTestStepResult(EPass);

  1001         }

  1003     return TestStepResult();

  1004     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--