1 /*

     2 * Copyright (c) 2000-2009 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 * TTextView.cpp test file for UndoSystem classes

    16 *

    17 */

    18 

    19 

    20 #include <e32test.h>

    21 

    22 #include <coemain.h>

    23 #include <frmtview.h>

    24 #include <txtrich.h>

    25 #include <conpics.h>

    26 #include <e32math.h>

    27 

    28 #include "form_and_etext_editor.h"

    29 #include "UndoSystem.h"

    30 #include "EditorUndo.h"

    31 #include "FRMPAGE.H"

    32 

    33 _LIT(KHello, "hello world");

    34 const TInt KPaginatePriority = -100;

    35 const TInt KGranularity = 10;

    36 

    37 using namespace UndoSystem;

    38 

    39 LOCAL_C TInt GetNumber(TInt aMin, TInt aMax)

    40 	{

    41 	__ASSERT_ALWAYS(aMin <= aMax, User::Invariant());

    42 

    43 	TInt64 seed = Math::Random();

    44 	TReal randomReal = Math::FRand(seed);

    45 

    46 	TReal maxReal = randomReal * ((aMax-aMin)+1);

    47 	TReal rounded = 0;

    48 	User::LeaveIfError(Math::Round(rounded, maxReal, 0));

    49 

    50 	TInt result = rounded + aMin;

    51 	

    52 	if(result> aMax)

    53 		{

    54 		return aMax;

    55 		}

    56 	return result;

    57 	}

    58 

    59 void ManipulateText(CTextView* aView, CRichText* aText)

    60 	{

    61 	_LIT(KStartText, "The quick brown fox jumped over the lazy dog.");

    62 	aText->InsertL(0, KStartText);

    63 	aView->HandleInsertDeleteL(TCursorSelection(0, KStartText().Length()), 0);

    64 	aText->InsertL(19, TChar(CEditableText::EParagraphDelimiter));

    65 	aView->HandleCharEditL();

    66 	TCharFormat format;

    67 	TCharFormatMask mask;

    68 	format.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

    69 	mask.ClearAll();

    70 	mask.SetAttrib(EAttFontStrokeWeight);

    71 	aText->ApplyCharFormatL(format, mask, 41, 3);

    72 	aView->HandleRangeFormatChangeL(TCursorSelection(41, 44));

    73 	aView->SetDocPosL(42);

    74 	TInt length = aText->DocumentLength();

    75 	aText->DeleteL(0, length);

    76 	aView->HandleInsertDeleteL(TCursorSelection(0, 0), length);

    77 	}

    78 

    79 void ManipulateText1(CTextView* aView, CRichText* aText)

    80 	{

    81 	TInt testaYPos = 0;

    82 	_LIT(KText, "The weather is quite good today, but it's a bit too cold");

    83 	aText->InsertL(0, KText);

    84 	aView->HandleInsertDeleteL(TCursorSelection(0, KText().Length()), 0);

    85 	aView->SetDocPosL(10); //56 is the position of the last character d

    86 	aView->SetViewLineAtTopL(1);

    87 	aView->SetViewL(50, testaYPos);

    88 	aView->HandleAdditionalCharactersAtEndL();

    89 	}

    90 

    91 inline TBool IsSurrogate(TText16 aInt16)

    92 /**

    93 @return True, if aText16 is high surrogate or low surrogate; false, otherwise.

    94 */

    95 	{

    96 	return (aInt16 & 0xF800) == 0xD800;

    97 	}

    98 

    99 class CMyTestPicture : public CPicture

   100 	{

   101 public:

   102 	static CMyTestPicture* NewL(TSize aSize);

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

   104 	void ExternalizeL(RWriteStream& /*aStream*/) const {}

   105 	void GetOriginalSizeInTwips(TSize& aSize) const {aSize=iSizeOfPicture;}

   106 private:

   107 	CMyTestPicture(TSize aSize);

   108 private:

   109 	TSize iSizeOfPicture;

   110 	};

   111 

   112 CMyTestPicture* CMyTestPicture::NewL(TSize aSize)

   113 	{

   114 	return new(ELeave) CMyTestPicture(aSize);

   115 	}

   116 

   117 

   118 CMyTestPicture::CMyTestPicture(TSize aSize):iSizeOfPicture(aSize)

   119 	{}

   120 

   121 

   122 class CTextViewTest : public CBase

   123 	{

   124 public:

   125 	CTextViewTest(CCoeEnv& aEnv)

   126 		: iEnv(aEnv), 	iWindowRect(10, 10, 110, 110), iWindow(aEnv.WsSession()),

   127 		test(_L("TTextView - Some tests for CTextView")) {}

   128 	void ConstructL();

   129 	void InitializeL();

   130 	void AddTextL(const TDesC&);

   131 	void Destroy();

   132 	~CTextViewTest();

   133 	void TestL();

   134 	void Test1L();

   135 	void TestCancelSelectionL();

   136 	void TestHandleAdditionalCharactersAtEndL();

   137 	void TestFinishBackgroundFormattingL();

   138 	void TestSetCursorVisibilityL();

   139 	void TestSetSelectionVisibilityL();

   140 	void TestEnablePictureFrameL();

   141 	void TestSetCursorWidthTypeL();

   142 	void TestParagraphRectL();

   143 	void TestSetDocPosL();

   144 	void TestSetViewLineAtTopL();

   145 	void TestDrawL();

   146 	void TestFormatTextL();

   147 	void TestHandleCharEditL();

   148 	void TestHandleRangeFormatChangeL();

   149 	void TestHandleInsertDeleteL();

   150 	void TestHandleGlobalChangeL();

   151 	void TestHandleGlobalChangeNoRedrawL();

   152 	void TestScrollDisplayL();

   153     void TestScrollDisplayPixelsL();

   154     void TestScrollDisplayPixelsNoLimitBordersL(TInt aOffset);

   155     void TestForDEF142286BounceScrollingL();

   156 	void TestScrollDisplayLinesL();

   157 	void TestScrollDisplayParagraphsL();

   158 	void TestSetViewL();

   159 	void TestMoveCursorL();

   160 	void TestSetSelectionL();

   161 	void TestMatchCursorHeightL();

   162 	void TestCalculateHorizontalExtremesL();

   163 	void TestXyPosToDocPosL();

   164 //	void TestDrawL1();

   165 	void TestGetPictureRectangleL();

   166 	void TestGetPictureRectangle1L();

   167 	void TestSetDisplayContextL();

   168 	void TestGetPictureRectangleDefectL();

   169 	void TestGetLineRectL(); // Test for defect WEP-567K9C Form panics when picture

   170 							 // inserted in CRichText and alignmnent is set to bottom

   171 	void TestForDEF003426L();

   172 	void TestForDEF038488L();

   173 	void InitializeDiffCharFormatL();

   174 	void TestGetParaFormatL();

   175 	// Function to test the Class TFormAndEtextEditor

   176 	void FormAndEtextTestL();

   177 	void TestForINC092725L();

   178 	void TestForPDEF108443L();

   179 	void TestForPDEF113755L();

   180 	void TestForPDEF115165L();

   181 	void TestForPDEF118443L();

   182 	void TestForPDEF121798L();

   183 	void TestForPDEF120239L();

   184 	void TestForDEF124989L();

   185 	void TestForDEF124975L();

   186 	

   187 	struct STestDataTInt4

   188 		{

   189 		TInt iDoc1;

   190 		TInt iDoc2; 

   191 		TInt iPos1;

   192 		TInt iPos2;		

   193 		};

   194 	

   195 private:

   196 	CCoeEnv& iEnv;

   197 	TRect iWindowRect;

   198 	CParaFormatLayer* iParaLayer;

   199 	CCharFormatLayer* iCharLayer;

   200 	CRichText* iEtext;

   201 	CTextLayout* iLayout;

   202 	RWindow iWindow;

   203 	CTextView* iView;

   204 	RTest test;

   205 	TCursorSelection select;

   206 	TInt testDeltaY;

   207 	TInt testDeltaLines;

   208 	TInt testDeltaParas;

   209 	TInt testaYPos;

   210 	TCursorPosition::TMovementType testaMovement;

   211 	TFontSpec testaFontSpec;

   212 	TInt testaLeft;

   213 	TInt testaRight;

   214 	TPoint testaPoint;

   215 	TBool testaCanScaleOrCrop;

   216 	CBitmapContext* testaGc;

   217 	TPoint testaXyPos;

   218 	CBitmapDevice* testaGd;

   219 	RWindowGroup testaGroupWin;

   220 	RWsSession testaSession;

   221 	};

   222 

   223 void CTextViewTest::ConstructL()

   224 	{

   225 	iWindow.Construct(iEnv.RootWin(), 12345);

   226 	iParaLayer = CParaFormatLayer::NewL();

   227 	iCharLayer = CCharFormatLayer::NewL();

   228 	test.Title();

   229 	test.Start(_L("CTextView Tests:"));

   230 	}

   231 

   232 void CTextViewTest::InitializeL()

   233 	{

   234 	Destroy();

   235 	iEtext = CRichText::NewL(iParaLayer, iCharLayer);

   236 	iLayout = CTextLayout::NewL(iEtext, iWindowRect.Width());

   237 	iView = CTextView::NewL(iLayout, iWindowRect, iEnv.ScreenDevice(),

   238 		iEnv.SystemGc().Device(), &iWindow, &iEnv.RootWin(), &iEnv.WsSession());

   239 	testaGd=(CBitmapDevice*) iEnv.SystemGc().Device();

   240 	}

   241 

   242 void CTextViewTest::AddTextL(const TDesC& aText)

   243 	{

   244 	iEtext->InsertL(0, aText);

   245 	TCursorSelection s(0, aText.Length());

   246 	iView->HandleInsertDeleteL(s, 0);

   247 	}

   248 

   249 void CTextViewTest::InitializeDiffCharFormatL()

   250 	{

   251 	Destroy();

   252 	delete iCharLayer;

   253 	iCharLayer=0;

   254 	TCharFormat charFormat;

   255 	TCharFormatMask charFormatMask;

   256 	charFormat.iFontPresentation.iPictureAlignment=TFontPresentation::EAlignBottom;

   257 	charFormatMask.SetAttrib(EAttFontPictureAlignment);

   258 	iCharLayer = CCharFormatLayer::NewL(charFormat,charFormatMask);

   259 	iEtext = CRichText::NewL(iParaLayer, iCharLayer);

   260 	iLayout = CTextLayout::NewL(iEtext, iWindowRect.Width());

   261 	iView = CTextView::NewL(iLayout, iWindowRect, iEnv.ScreenDevice(),

   262 		iEnv.SystemGc().Device(), &iWindow, &iEnv.RootWin(), &iEnv.WsSession());

   263 	testaGd=(CBitmapDevice*) iEnv.SystemGc().Device();

   264 	}

   265 

   266 void CTextViewTest::Destroy()

   267 	{

   268 	delete iView;

   269 	iView = 0;

   270 	delete iLayout;

   271 	iLayout = 0;

   272 	delete iEtext;

   273 	iEtext = 0;

   274 	}

   275 

   276 

   277 void CTextViewTest::TestL()

   278 	{

   279 	// Test for fix to ASR-4UYHZX: ETEXT panic 12 (ECharPosBeyondDocument) when

   280 	// out of memory

   281 	InitializeL();

   282 	ManipulateText(iView, iEtext);

   283 	Destroy();

   284 	TInt consecutiveSuccesses = 0;

   285 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   286 		{

   287 		__UHEAP_MARK;

   288 		InitializeL();

   289 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   290 		TRAPD(err, ManipulateText(iView, iEtext));

   291 		Destroy();

   292 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   293 		__UHEAP_MARKENDC(0);

   294 		if (err == KErrNone)

   295 			++consecutiveSuccesses;

   296 		else

   297 			consecutiveSuccesses = 0;

   298 		}

   299 	}

   300 

   301 

   302 void CTextViewTest::Test1L()

   303 	{

   304 	// testing functions SetViewL, SetViewLineAtTopL,

   305 	// SetDocPosL & HandleAdditionalCharactersAtEndL

   306 	// - should work but need some kind

   307 	// of pre-settings and initialization before they can all be proved

   308 	// that there is no memory leak

   309 	InitializeL();

   310 	ManipulateText1(iView, iEtext); //where all pre-settings have been done

   311 	Destroy();

   312 	TInt consecutiveSuccesses = 0;

   313 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   314 		{

   315 		__UHEAP_MARK;

   316 		InitializeL();

   317 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   318 		TRAPD(err, ManipulateText1(iView, iEtext));

   319 		Destroy();

   320 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   321 		__UHEAP_MARKENDC(0);

   322 		if (err == KErrNone)

   323 			++consecutiveSuccesses;

   324 		else

   325 			consecutiveSuccesses = 0;

   326 		}

   327 	}

   328 

   329 

   330 void CTextViewTest::TestCancelSelectionL()

   331 	{

   332 	InitializeL();

   333 	iView->CancelSelectionL();

   334 	Destroy();

   335 	TInt consecutiveSuccesses = 0;

   336 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   337 		{

   338 		__UHEAP_MARK;

   339 		InitializeL();

   340 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   341 		TRAPD(err, iView->CancelSelectionL());

   342 		Destroy();

   343 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   344 		__UHEAP_MARKENDC(0);

   345 		if (err == KErrNone)

   346 			++consecutiveSuccesses;

   347 		else

   348 			consecutiveSuccesses = 0;

   349 		}

   350 	}

   351 

   352 

   353 void CTextViewTest::TestFinishBackgroundFormattingL()

   354 	{

   355 	InitializeL();

   356 	iView->FinishBackgroundFormattingL();

   357 	Destroy();

   358 	TInt consecutiveSuccesses = 0;

   359 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   360 		{

   361 		__UHEAP_MARK;

   362 		InitializeL();

   363 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   364 		TRAPD(err, iView->FinishBackgroundFormattingL());

   365 		Destroy();

   366 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   367 		__UHEAP_MARKENDC(0);

   368 		if (err == KErrNone)

   369 			++consecutiveSuccesses;

   370 		else

   371 			consecutiveSuccesses = 0;

   372 		}

   373 	}

   374 

   375 

   376 void CTextViewTest::TestFormatTextL()

   377 	{

   378 	InitializeL();

   379 	iView->FormatTextL();

   380 	Destroy();

   381 	TInt consecutiveSuccesses = 0;

   382 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   383 		{

   384 		__UHEAP_MARK;

   385 		InitializeL();

   386 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   387 		TRAPD(err, iView->FormatTextL());

   388 		Destroy();

   389 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   390 		__UHEAP_MARKENDC(0);

   391 		if (err == KErrNone)

   392 			++consecutiveSuccesses;

   393 		else

   394 			consecutiveSuccesses = 0;

   395 		}

   396 	}

   397 

   398 

   399 void CTextViewTest::TestSetCursorVisibilityL()

   400 	{

   401 	InitializeL();

   402 	iView->SetCursorVisibilityL(1,1);

   403 	Destroy();

   404 	TInt consecutiveSuccesses = 0;

   405 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   406 		{

   407 		__UHEAP_MARK;

   408 		InitializeL();

   409 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   410 		TRAPD(err, iView->SetCursorVisibilityL(1,1)); //TInt aLineCursor, TInt aTextCursor

   411 		Destroy();

   412 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   413 		__UHEAP_MARKENDC(0);

   414 		if (err == KErrNone)

   415 			++consecutiveSuccesses;

   416 		else

   417 			consecutiveSuccesses = 0;

   418 		}

   419 	}

   420 

   421 

   422 void CTextViewTest::TestSetSelectionVisibilityL()

   423 	{

   424 	InitializeL();

   425 	iView->SetSelectionVisibilityL(1);

   426 	Destroy();

   427 	TInt consecutiveSuccesses = 0;

   428 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   429 		{

   430 		__UHEAP_MARK;

   431 		InitializeL();

   432 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   433 		TRAPD(err, iView->SetSelectionVisibilityL(1)); //TBool aSelectionVisible

   434 		Destroy();

   435 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   436 		__UHEAP_MARKENDC(0);

   437 		if (err == KErrNone)

   438 			++consecutiveSuccesses;

   439 		else

   440 			consecutiveSuccesses = 0;

   441 		}

   442 	}

   443 

   444 

   445 void CTextViewTest::TestEnablePictureFrameL()

   446 	{

   447 	InitializeL();

   448 	iView->EnablePictureFrameL(1);

   449 	Destroy();

   450 	TInt consecutiveSuccesses = 0;

   451 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   452 		{

   453 		__UHEAP_MARK;

   454 		InitializeL();

   455 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   456 		TRAPD(err, iView->EnablePictureFrameL(1)); //TBool aEnabled

   457 		Destroy();

   458 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   459 		__UHEAP_MARKENDC(0);

   460 		if (err == KErrNone)

   461 			++consecutiveSuccesses;

   462 		else

   463 			consecutiveSuccesses = 0;

   464 		}

   465 	}

   466 

   467 

   468 void CTextViewTest::TestSetCursorWidthTypeL()

   469 	{

   470 	InitializeL();

   471 	iView->SetCursorWidthTypeL(TTextCursor::ETypeRectangle,0);

   472 	Destroy();

   473 	TInt consecutiveSuccesses = 0;

   474 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   475 		{

   476 		__UHEAP_MARK;

   477 		InitializeL();

   478 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   479 		TRAPD(err, iView->SetCursorWidthTypeL(TTextCursor::ETypeRectangle,0)); //TTextCursor::EType aType, TInt aWidth=0

   480 		Destroy();

   481 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   482 		__UHEAP_MARKENDC(0);

   483 		if (err == KErrNone)

   484 			++consecutiveSuccesses;

   485 		else

   486 			consecutiveSuccesses = 0;

   487 		}

   488 	}

   489 

   490 

   491 void CTextViewTest::TestParagraphRectL()

   492 	{

   493 	InitializeL();

   494 	iView->ParagraphRectL(1);

   495 	Destroy();

   496 	TInt consecutiveSuccesses = 0;

   497 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   498 		{

   499 		__UHEAP_MARK;

   500 		InitializeL();

   501 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   502 		TRAPD(err, iView->ParagraphRectL(1)); //TInt aDocPos

   503 		Destroy();

   504 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   505 		__UHEAP_MARKENDC(0);

   506 		if (err == KErrNone)

   507 			++consecutiveSuccesses;

   508 		else

   509 			consecutiveSuccesses = 0;

   510 		}

   511 	}

   512 

   513 

   514 void CTextViewTest::TestDrawL()

   515 	{

   516 	InitializeL();

   517 	iView->DrawL(iWindowRect);

   518 	Destroy();

   519 	TInt consecutiveSuccesses = 0;

   520 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   521 		{

   522 		__UHEAP_MARK;

   523 		InitializeL();

   524 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   525 		TRAPD(err, iView->DrawL(iWindowRect)); //TRect aRect

   526 		Destroy();

   527 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   528 		__UHEAP_MARKENDC(0);

   529 		if (err == KErrNone)

   530 			++consecutiveSuccesses;

   531 		else

   532 			consecutiveSuccesses = 0;

   533 		}

   534 	}

   535 

   536 

   537 void CTextViewTest::TestHandleRangeFormatChangeL()

   538 	{

   539 	InitializeL();

   540 	iView->HandleRangeFormatChangeL(select, EFalse);

   541 	Destroy();

   542 	TInt consecutiveSuccesses = 0;

   543 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   544 		{

   545 		__UHEAP_MARK;

   546 		InitializeL();

   547 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   548 		TRAPD(err, iView->HandleRangeFormatChangeL(select, EFalse));

   549 		Destroy();

   550 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   551 		__UHEAP_MARKENDC(0);

   552 		if (err == KErrNone)

   553 			++consecutiveSuccesses;

   554 		else

   555 			consecutiveSuccesses = 0;

   556 		}

   557 	}

   558 

   559 

   560 void CTextViewTest::TestHandleInsertDeleteL()

   561 	{

   562 	InitializeL();

   563 	iView->HandleInsertDeleteL(select, 1, EFalse);

   564 	Destroy();

   565 	TInt consecutiveSuccesses = 0;

   566 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   567 		{

   568 		__UHEAP_MARK;

   569 		InitializeL();

   570 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   571 		TRAPD(err, iView->HandleInsertDeleteL(select, 1, EFalse));

   572 		Destroy();

   573 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   574 		__UHEAP_MARKENDC(0);

   575 		if (err == KErrNone)

   576 			++consecutiveSuccesses;

   577 		else

   578 			consecutiveSuccesses = 0;

   579 		}

   580 	}

   581 

   582 

   583 void CTextViewTest::TestHandleGlobalChangeL()

   584 	{

   585 	InitializeL();

   586 	iView->HandleGlobalChangeL(TViewYPosQualifier());

   587 	Destroy();

   588 	TInt consecutiveSuccesses = 0;

   589 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   590 		{

   591 		__UHEAP_MARK;

   592 		InitializeL();

   593 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   594 		TRAPD(err, iView->HandleGlobalChangeL(TViewYPosQualifier()));

   595 		Destroy();

   596 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   597 		__UHEAP_MARKENDC(0);

   598 		if (err == KErrNone)

   599 			++consecutiveSuccesses;

   600 		else

   601 			consecutiveSuccesses = 0;

   602 		}

   603 	}

   604 

   605 

   606 void CTextViewTest::TestHandleGlobalChangeNoRedrawL()

   607 	{

   608 	InitializeL();

   609 	iView->HandleGlobalChangeNoRedrawL(TViewYPosQualifier());

   610 	Destroy();

   611 	TInt consecutiveSuccesses = 0;

   612 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   613 		{

   614 		__UHEAP_MARK;

   615 		InitializeL();

   616 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   617 		TRAPD(err, iView->HandleGlobalChangeNoRedrawL(TViewYPosQualifier()));

   618 		Destroy();

   619 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   620 		__UHEAP_MARKENDC(0);

   621 		if (err == KErrNone)

   622 			++consecutiveSuccesses;

   623 		else

   624 			consecutiveSuccesses = 0;

   625 		}

   626 	}

   627 

   628 

   629 void CTextViewTest::TestScrollDisplayL()

   630 	{

   631 	InitializeL();

   632 	iView->ScrollDisplayL(TCursorPosition::EFLeft);

   633 	Destroy();

   634 	TInt consecutiveSuccesses = 0;

   635 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   636 		{

   637 		__UHEAP_MARK;

   638 		InitializeL();

   639 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   640 		TRAPD(err, iView->ScrollDisplayL(TCursorPosition::EFLeft));

   641 		Destroy();

   642 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   643 		__UHEAP_MARKENDC(0);

   644 		if (err == KErrNone)

   645 			++consecutiveSuccesses;

   646 		else

   647 			consecutiveSuccesses = 0;

   648 		}

   649 	}

   650 

   651 

   652 void CTextViewTest::TestScrollDisplayPixelsL()

   653 	{

   654 	InitializeL();

   655 	iView->ScrollDisplayPixelsL(testDeltaY);

   656 	Destroy();

   657 	TInt consecutiveSuccesses = 0;

   658 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   659 		{

   660 		__UHEAP_MARK;

   661 		InitializeL();

   662 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   663 		TRAPD(err, iView->ScrollDisplayPixelsL(testDeltaY));

   664 		Destroy();

   665 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   666 		__UHEAP_MARKENDC(0);

   667 		if (err == KErrNone)

   668 			++consecutiveSuccesses;

   669 		else

   670 			consecutiveSuccesses = 0;

   671 		}

   672 	}

   673 

   674 

   675 void CTextViewTest::TestScrollDisplayPixelsNoLimitBordersL(TInt aOffset)

   676     { 

   677     /*

   678      * This test case is for new added function ScrollDisplayPixelsNoLimitBorderL() which support

   679      * no limit scrolling, using this function text view can be scrolled beyond the top and bottom 

   680      * border.

   681      * Text view will be firstly scrolled to border using ScrollDisplayPixelsL() which can't scroll

   682      * text view beyond the top or bottom border.

   683      * Then text view will be scrolled using ScrollDisplayPixelsNoLimitBorderL() to same direction.

   684      * Code will test this step that if text view is really scrolled beyond the border by checking 

   685      * the iBandTop position before and after the scrolling operation.*/

   686     

   687     InitializeL();

   688     _LIT(KTestParagraph, "This is a piece of text which is used to test the bounce scrolling feature made by s60.");

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

   690         AddTextL(KTestParagraph);

   691     

   692     TInt firstBandTop, secondBandTop;

   693     TInt offset = aOffset;

   694     while( offset!=0 )

   695         {

   696         iView->ScrollDisplayPixelsL(offset);

   697         }

   698     offset = aOffset;

   699     firstBandTop = iLayout->PixelsAboveBand();

   700     iView->ScrollDisplayPixelsNoLimitBorderL(offset);

   701     secondBandTop = iLayout->PixelsAboveBand();

   702     test(firstBandTop - secondBandTop == offset);

   703 

   704     offset = 0 - aOffset;

   705     while( offset!=0 )

   706         {

   707         iView->ScrollDisplayPixelsL(offset);

   708         }

   709     offset = 0 - aOffset;

   710     firstBandTop = iLayout->PixelsAboveBand();

   711     iView->ScrollDisplayPixelsNoLimitBorderL(offset);

   712     secondBandTop = iLayout->PixelsAboveBand();

   713     test(firstBandTop - secondBandTop == offset);

   714     

   715     Destroy();

   716     }

   717 

   718 

   719 void CTextViewTest::TestScrollDisplayLinesL()

   720 	{

   721 	InitializeL();

   722 	iView->ScrollDisplayLinesL(testDeltaLines);

   723 	Destroy();

   724 	TInt consecutiveSuccesses = 0;

   725 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   726 		{

   727 		__UHEAP_MARK;

   728 		InitializeL();

   729 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   730 		TRAPD(err, iView->ScrollDisplayLinesL(testDeltaLines));

   731 		Destroy();

   732 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   733 		__UHEAP_MARKENDC(0);

   734 		if (err == KErrNone)

   735 			++consecutiveSuccesses;

   736 		else

   737 			consecutiveSuccesses = 0;

   738 		}

   739 	}

   740 

   741 

   742 void CTextViewTest::TestScrollDisplayParagraphsL()

   743 	{

   744 	InitializeL();

   745 	AddTextL(KHello);

   746 	iView->ScrollDisplayParagraphsL(testDeltaParas);

   747 	Destroy();

   748 	TInt consecutiveSuccesses = 0;

   749 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   750 		{

   751 		__UHEAP_MARK;

   752 		InitializeL();

   753 		AddTextL(KHello);

   754 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   755 		TRAPD(err, iView->ScrollDisplayParagraphsL(testDeltaParas));

   756 		Destroy();

   757 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   758 		__UHEAP_MARKENDC(0);

   759 		if (err == KErrNone)

   760 			++consecutiveSuccesses;

   761 		else

   762 			consecutiveSuccesses = 0;

   763 		}

   764 	}

   765 

   766 

   767 void CTextViewTest::TestSetViewL()

   768 	{

   769 	InitializeL();

   770 	iView->SetViewL(1, testaYPos);

   771 	Destroy();

   772 	TInt consecutiveSuccesses = 0;

   773 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   774 		{

   775 		__UHEAP_MARK;

   776 		InitializeL();

   777 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   778 		TRAPD(err, iView->SetViewL(1, testaYPos));

   779 		Destroy();

   780 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   781 		__UHEAP_MARKENDC(0);

   782 		if (err == KErrNone)

   783 			++consecutiveSuccesses;

   784 		else

   785 			consecutiveSuccesses = 0;

   786 		}

   787 	}

   788 

   789 

   790 void CTextViewTest::TestMoveCursorL()

   791 	{

   792 	InitializeL();

   793 	AddTextL(KHello);

   794 	iView->MoveCursorL(testaMovement, EFalse);

   795 	Destroy();

   796 	TInt consecutiveSuccesses = 0;

   797 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   798 		{

   799 		__UHEAP_MARK;

   800 		InitializeL();

   801 		AddTextL(KHello);

   802 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   803 		TRAPD(err, iView->MoveCursorL(testaMovement, EFalse));

   804 		Destroy();

   805 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   806 		__UHEAP_MARKENDC(0);

   807 		if (err == KErrNone)

   808 			++consecutiveSuccesses;

   809 		else

   810 			consecutiveSuccesses = 0;

   811 		}

   812 	}

   813 

   814 

   815 void CTextViewTest::TestSetSelectionL()

   816 	{

   817 	InitializeL();

   818 	iView->SetSelectionL(select);

   819 	Destroy();

   820 	TInt consecutiveSuccesses = 0;

   821 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   822 		{

   823 		__UHEAP_MARK;

   824 		InitializeL();

   825 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   826 		TRAPD(err, iView->SetSelectionL(select));

   827 		Destroy();

   828 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   829 		__UHEAP_MARKENDC(0);

   830 		if (err == KErrNone)

   831 			++consecutiveSuccesses;

   832 		else

   833 			consecutiveSuccesses = 0;

   834 		}

   835 	}

   836 

   837 

   838 void CTextViewTest::TestMatchCursorHeightL()

   839 	{

   840 	InitializeL();

   841 	iView->MatchCursorHeightL(testaFontSpec);

   842 	Destroy();

   843 	TInt consecutiveSuccesses = 0;

   844 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   845 		{

   846 		__UHEAP_MARK;

   847 		InitializeL();

   848 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   849 		TRAPD(err, iView->MatchCursorHeightL(testaFontSpec));

   850 		Destroy();

   851 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   852 		__UHEAP_MARKENDC(0);

   853 		if (err == KErrNone)

   854 			++consecutiveSuccesses;

   855 		else

   856 			consecutiveSuccesses = 0;

   857 		}

   858 	}

   859 

   860 

   861 void CTextViewTest::TestCalculateHorizontalExtremesL()

   862 	{

   863 	InitializeL();

   864 	iView->CalculateHorizontalExtremesL(testaLeft, testaRight, EFalse);

   865 	Destroy();

   866 	TInt consecutiveSuccesses = 0;

   867 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   868 		{

   869 		__UHEAP_MARK;

   870 		InitializeL();

   871 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   872 		TRAPD(err, iView->CalculateHorizontalExtremesL(testaLeft, testaRight, EFalse));

   873 		Destroy();

   874 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   875 		__UHEAP_MARKENDC(0);

   876 		if (err == KErrNone)

   877 			++consecutiveSuccesses;

   878 		else

   879 			consecutiveSuccesses = 0;

   880 		}

   881 	}

   882 

   883 

   884 void CTextViewTest::TestXyPosToDocPosL()

   885 	{

   886 	InitializeL();

   887 	iView->XyPosToDocPosL(testaPoint);

   888 	Destroy();

   889 	TInt consecutiveSuccesses = 0;

   890 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   891 		{

   892 		__UHEAP_MARK;

   893 		InitializeL();

   894 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   895 		TRAPD(err, iView->XyPosToDocPosL(testaPoint));

   896 		Destroy();

   897 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   898 		__UHEAP_MARKENDC(0);

   899 		if (err == KErrNone)

   900 			++consecutiveSuccesses;

   901 		else

   902 			consecutiveSuccesses = 0;

   903 		}

   904 	}

   905 

   906 /*

   907 void CTextViewTest::TestDrawL1()

   908 	{

   909 	InitializeL();

   910 	iView->DrawL(iWindowRect, testaGc);

   911 	Destroy();

   912 	TInt consecutiveSuccesses = 0;

   913 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   914 		{

   915 		__UHEAP_MARK;

   916 		InitializeL();

   917 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   918 		TRAPD(err, iView->DrawL(iWindowRect, testaGc));

   919 		Destroy();

   920 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   921 		__UHEAP_MARKENDC(0);

   922 		if (err == KErrNone)

   923 			++consecutiveSuccesses;

   924 		else

   925 			consecutiveSuccesses = 0;

   926 		}

   927 	}

   928 */

   929 

   930 

   931 void CTextViewTest::TestGetPictureRectangleL()

   932 	{

   933 	InitializeL();

   934 	iView->GetPictureRectangleL(1, iWindowRect, &testaCanScaleOrCrop);

   935 	Destroy();

   936 	TInt consecutiveSuccesses = 0;

   937 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   938 		{

   939 		__UHEAP_MARK;

   940 		InitializeL();

   941 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   942 		TRAPD(err, iView->GetPictureRectangleL(1, iWindowRect, &testaCanScaleOrCrop));

   943 		Destroy();

   944 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   945 		__UHEAP_MARKENDC(0);

   946 		if (err == KErrNone)

   947 			++consecutiveSuccesses;

   948 		else

   949 			consecutiveSuccesses = 0;

   950 		}

   951 	}

   952 

   953 

   954 void CTextViewTest::TestGetPictureRectangle1L()

   955 	{

   956 	InitializeL();

   957 	iView->GetPictureRectangleL(testaXyPos, iWindowRect, &testaCanScaleOrCrop);

   958 	Destroy();

   959 	TInt consecutiveSuccesses = 0;

   960 	for (TInt i = 1; consecutiveSuccesses != 100; ++i)

   961 		{

   962 		__UHEAP_MARK;

   963 		InitializeL();

   964 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   965 		TRAPD(err, iView->GetPictureRectangleL(testaXyPos, iWindowRect, &testaCanScaleOrCrop));

   966 		Destroy();

   967 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   968 		__UHEAP_MARKENDC(0);

   969 		if (err == KErrNone)

   970 			++consecutiveSuccesses;

   971 		else

   972 			consecutiveSuccesses = 0;

   973 		}

   974 	}

   975 

   976 

   977 void CTextViewTest::TestSetDisplayContextL()

   978 	{

   979 	CBitmapContext* atestGc;

   980 	CBitmapContext* anotherGc;

   981 	InitializeL();

   982 	iView->SetDisplayContextL(testaGd, &iWindow, &testaGroupWin, &testaSession);

   983 	Destroy();

   984 	TInt consecutiveSuccesses = 0;

   985 	for (TInt i = 1; consecutiveSuccesses != 1; ++i)

   986 		{

   987 		__UHEAP_MARK;

   988 		InitializeL();

   989 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);

   990 		atestGc=iView->BitmapContext();

   991 		TRAPD(err, iView->SetDisplayContextL(testaGd, &iWindow, &testaGroupWin, &testaSession));

   992 		anotherGc=iView->BitmapContext();

   993 		if (err)

   994 			{

   995 			test(atestGc==anotherGc);

   996 			}

   997 		else

   998 			{

   999 			test(atestGc!=anotherGc);

  1000 			}

  1001 		Destroy();

  1002 		__UHEAP_SETFAIL(RHeap::ENone, 0);

  1003 		__UHEAP_MARKENDC(0);

  1004 		if (err == KErrNone)

  1005 			++consecutiveSuccesses;

  1006 		else

  1007 			consecutiveSuccesses = 0;

  1008 		}

  1009 	}

  1010 

  1011 

  1012 void CTextViewTest::TestGetPictureRectangleDefectL()

  1013 	{

  1014 	/*

  1015 	_LIT(KParagraphAverage,"Some text to test that the Picture returned is in the correct position. The size of this paragraph should be reasonable, not too long not too short.");

  1016 	_LIT(KParagraphBigger,"Moulin Rouge: a film review. I don't know what I was expecting from Oulin Rouge, but what I got came as an even more of a surprise. The movie is a visual feast, a sing along extravaganza. The choices of songs is refreshing, with mix of Nirvan-Smells like teen spirit- to Madonna-Like a virgin-. Who knew that Ewan and Nicole could sing so well together.");

  1017 	_LIT(KParagraphSmall,"CBusBase is an abstract base class for dynamic memory buffers. You can read or write bytes.");

  1018 	InitializeL();

  1019 	TInt length;

  1020 	iEtext->InsertL(0,KParagraphAverage);

  1021 	iView->HandleInsertDeleteL(TCursorSelection(0, KParagraphAverage().Length()), 0);

  1022 	iEtext->InsertL(KParagraphAverage().Length(),TChar(CEditableText::EParagraphDelimiter));

  1023 	iView->HandleCharEditL();

  1024 

  1025 	length=iEtext->LdDocumentLength();

  1026 	iEtext->InsertL(iEtext->LdDocumentLength(),KParagraphBigger);

  1027 	iView->HandleInsertDeleteL(TCursorSelection(length,KParagraphBigger().Length()), 0);

  1028 

  1029 	length=iEtext->LdDocumentLength();

  1030 	iEtext->InsertL(iEtext->LdDocumentLength(),KParagraphSmall);

  1031 	iView->HandleInsertDeleteL(TCursorSelection(length,KParagraphSmall().Length()), 0);

  1032 

  1033 	TSize size(100,100);

  1034 	TPoint xypos;

  1035 	CMyTestPicture* testpicture1 = CMyTestPicture::NewL(size);

  1036 	CMyTestPicture* testpicture2 = CMyTestPicture::NewL(size);

  1037 	CMyTestPicture* testpicture3 = CMyTestPicture::NewL(size);

  1038 	size.SetSize(200,200);

  1039 	CMyTestPicture* testpicture4 = CMyTestPicture::NewL(size);

  1040 	CMyTestPicture* testpicture5 = CMyTestPicture::NewL(size);

  1041 	CMyTestPicture* testpicture6 = CMyTestPicture::NewL(size);

  1042 	TPictureHeader mypic;

  1043 	TPictureHeader mypic2;

  1044 	//mypic.iPictureType = KUidXzePictureType;

  1045 	mypic.iPicture=testpicture1;

  1046 	mypic2.iPicture=testpicture2;

  1047 	// Testing the picture

  1048 

  1049 	iEtext->InsertL(10,mypic2);

  1050 	mypic2.iPicture=testpicture1;

  1051 	iEtext->InsertL(40,mypic2);

  1052 	iView->DocPosToXyPosL(200,xypos);

  1053 	test.Printf(_L("The xy coords are %d & %d\n"),xypos.iX,xypos.iY);

  1054 	xypos.SetXY(78,55);

  1055 	TInt docpos;

  1056 	docpos=iView->XyPosToDocPosL(xypos);

  1057 	test.Printf(_L("The new docpos is %d\n"),docpos);

  1058 	TRect rect;

  1059 	TBool boo;

  1060 	boo=iView->GetPictureRectangleL(40,rect);

  1061 	test.Printf(_L("%d & %d \n"),rect.Size().iHeight,rect.Size().iWidth);

  1062 	if (boo)

  1063 		test.Printf(_L("Yes!"));

  1064 	else

  1065 		test.Printf(_L("Noo!"));

  1066 	*/

  1067 	}

  1068 

  1069 void CTextViewTest::TestGetLineRectL()

  1070 	{

  1071 

  1072 	_LIT(KSomeText,"Empty. Well this text has to now be something else. Maybe this will increase the height of the CTextLayout and if it does then");

  1073 	// calls the initializeDiffCharFormatL to set the new CharFormatLayer

  1074 	// which sets the picture alignment to be Bottom.

  1075 	InitializeDiffCharFormatL();

  1076 	// create test pictures to be inserted into the richtext object

  1077 	TSize size(100,100);

  1078 	CMyTestPicture* testpicture1 = CMyTestPicture::NewL(size);

  1079 	TPictureHeader tPicHeader;

  1080 	tPicHeader.iPictureType = KUidXzePictureType;

  1081 	tPicHeader.iPicture = testpicture1;

  1082 	test.Printf(_L("Created a picture\n"));

  1083 

  1084 	// inserting some text & picture into the richtext object

  1085 	iEtext->InsertL(0,KSomeText);

  1086 	TInt startOfPicture;

  1087 	startOfPicture=iEtext->DocumentLength();

  1088 	iEtext->InsertL(startOfPicture,tPicHeader);

  1089 	test.Printf(_L("Inserted the picture in CRichText object \n"));

  1090 

  1091 	//Call the guilty function

  1092 	TRect resultingRect;

  1093 	TInt endOfDocument = iEtext->DocumentLength();

  1094 	iView->FormatTextL();

  1095 	resultingRect=iLayout->GetLineRectL(startOfPicture,endOfDocument);

  1096 	}

  1097 

  1098 void CTextViewTest::TestGetParaFormatL()

  1099 	{

  1100 	test.Next(_L("Starting GetParaFormatL test"));

  1101 	_LIT(KSomeText,"Empty. Well this text has to now be something else. Maybe this will increase the height of the CTextLayout and if it does then");

  1102 	InitializeL();

  1103 	// create the CParaFormat & TparaFormatMask

  1104 	// and set that in the iParaFormatLayer

  1105 	CParaFormat* paraFormat = CParaFormat::NewL();

  1106 	TParaFormatMask paraFormatMask;

  1107 	iParaLayer->SetL(paraFormat,paraFormatMask);

  1108 	iEtext->SetGlobalParaFormat(iParaLayer);

  1109 	iEtext->InsertL(0,KSomeText);

  1110 	iView->FormatTextL();

  1111 	// Create another CParaFormat & TParaFormatMask and set

  1112 	// some attributes to be different from the default.

  1113 	CParaFormat* anotherParaFormat = CParaFormat::NewL();

  1114 	TParaFormatMask anotherParaFormatMask;

  1115 	anotherParaFormat->iRightMarginInTwips=200;

  1116 	anotherParaFormatMask.SetAttrib(EAttRightMargin);

  1117 	anotherParaFormat->iLeftMarginInTwips=400;

  1118 	anotherParaFormatMask.SetAttrib(EAttLeftMargin);

  1119 	anotherParaFormat->iLineSpacingInTwips=300;

  1120 	anotherParaFormatMask.SetAttrib(EAttLineSpacing);

  1121 	anotherParaFormat->iHorizontalAlignment=CParaFormat::ERightAlign;

  1122 	anotherParaFormatMask.SetAttrib(EAttAlignment);

  1123 

  1124 	//Now call CRichText::GetParaFormat using anotherParaFormat * Mask

  1125 	// and test that it is the same as paraFormat.

  1126  	iEtext->GetParaFormatL(anotherParaFormat,anotherParaFormatMask,0,10);

  1127 

  1128 	TInt result = anotherParaFormat->iRightMarginInTwips;

  1129 	test (result==0);

  1130 

  1131 	result = anotherParaFormat->iLeftMarginInTwips;

  1132 	test (result==0);

  1133 	result = anotherParaFormat->iLineSpacingInTwips;

  1134 	test (result==200); // default value for iLineSpacingInTwips set in paraFormat is 200