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 <txtfmlyr.h>

    20 #include <txtrich.h>

    21 #include <txtfrmat.h>

    22 #include <gdi.h>

    23 #include "T_FMT.h"

    25 LOCAL_D CTestStep *pTestStep = NULL;

    26 #define test(cond)											\

    27 	{														\

    28 	TBool __bb = (cond);									\

    29 	pTestStep->TEST(__bb);									\

    30 	if (!__bb)												\

    31 		{													\

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

    33 		User::Leave(1);										\

    34 		}													\

    35 	}

    36 #undef INFO_PRINTF1

    37 #undef INFO_PRINTF2

    38 // copy from tefexportconst.h

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

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

    42 template<class S>

    43 class TestFormat

    44 	{

    45 public:

    46 	void CheckAllClassesL();

    47 	void CheckTTabStop();

    48 	void CheckTParaBorder();

    49 	void CheckTBullet();

    50 	void CheckCParaFormatL();

    51 	void CheckCParaFormatSpecialL();

    52 	void CheckCParaFormatTabsEqual(TTabStop& aChecl,TTabStop& aControl);

    53 	void CheckTParaFormatMask();

    54 	void CheckCParaFormatLayerL();

    55 	void CheckCParaFormatLayerRestL();

    56 	void CheckTCharFormat();

    57 	void CheckTCharFormatMask();

    58 	void CheckCCharFormatLayerL();

    59 	void CheckFormatsEqual(CParaFormat* aControl,CParaFormat* aCheck);

    60 	void CheckFormatsEqual(TCharFormat& aControl,TCharFormatMask& aControlMask,TCharFormat& aCheck,TCharFormatMask& aMask);

    61 	void CheckFormatsEqual(TParaFormatMask& aControl,TParaFormatMask& aCheck);

    62 	void CheckFormatsEqual(TCharFormatMask& aControl,TCharFormatMask& aCheck);

    63 	};

    66 template<class S>

    67 void TestFormat<S>::CheckTTabStop()

    68 //

    69 // Checks TTabStop construction and methods.

    70 //

    71 	{

    72 	INFO_PRINTF1(_L("Checking all methods"));

    74 	// Default constructor.

    75 	TTabStop tab1;

    76 	// Assignment operator.

    77 	TTabStop tab3;

    78 	tab3=tab1;

    80 	INFO_PRINTF1(_L("Default constructor"));

    81 	test(tab1.iTwipsPosition==0);

    82 	if (tab1.iType==TTabStop::ELeftTab)

    83 	    INFO_PRINTF2(_L("\nleft tab - %d\n"),tab1.iType);

    84 	else if (tab1.iType==TTabStop::ECenteredTab)

    85 	    INFO_PRINTF2(_L("\ncentered tab - %d\n"),tab1.iType);

    86 	else if (tab1.iType==TTabStop::ERightTab)

    87 	    INFO_PRINTF2(_L("\nright tab - %d\n"),tab1.iType);

    88 	else if (tab1.iType==TTabStop::ENullTab)

    89 	    INFO_PRINTF2(_L("\nnull tab - %d\n"),tab1.iType);

    90 	else

    91 	    INFO_PRINTF2(_L("\nsomething completely different - %d \n"),tab1.iType);

    92 	test(tab1.iType==TTabStop::ELeftTab);

    93 //	test.Getch();

    95 	INFO_PRINTF1(_L("Copy constructor"));

    96 	TTabStop tab4;

    97 	tab4.iTwipsPosition=1440;

    98 	tab4.iType=TTabStop::ERightTab;

    99 	TTabStop tab5(tab4);

   100 	test(tab5.iTwipsPosition==tab4.iTwipsPosition);

   101 	test(tab5.iType==tab4.iType);

   103 	INFO_PRINTF1(_L("Assignment operator"));

   104 	tab1=tab5;;

   105 	test(tab1.iTwipsPosition==tab5.iTwipsPosition);

   106 	test(tab1.iType==tab5.iType);

   108 	INFO_PRINTF1(_L("Equality operator"));

   109 	test(tab1==tab5);

   111 	INFO_PRINTF1(_L("Inequality operator"));

   112 	tab1.iTwipsPosition=2;

   113 	test(tab1!=tab5);

   114 	}

   117 template<class S>

   118 void TestFormat<S>::CheckTParaBorder()

   119 //

   120 // Checks TParaBorder construction.

   121 //

   122 	{

   123 	INFO_PRINTF1(_L("Checking all methods"));

   124 	// Default Constructor.

   125 	TParaBorder border1;

   127 	INFO_PRINTF1(_L("Default constructor"));

   128 	test(border1.iLineStyle==TParaBorder::ENullLineStyle);

   129 	test(border1.iAutoColor);

   130 	TLogicalRgb c(TLogicalRgb::ESystemForegroundColor);

   131 	test(border1.iColor == c);

   133 	TParaBorder border2;

   134 	INFO_PRINTF1(_L("Equality operator"));

   135 	test(border2==border1);

   137 	INFO_PRINTF1(_L("Inequality operator"));

   138 	border2.iLineStyle=TParaBorder::ESolid;

   139 	border2.iThickness=2;

   140 	test(border2!=border1);

   142 	border1.iLineStyle=TParaBorder::ESolid;

   143 	border1.iThickness=2;

   144 	test(border2==border1);

   145 	}

   148 template<class S>

   149 void TestFormat<S>::CheckTBullet()

   150 //

   151 // Checks TBullet construction.

   152 //

   153 	{

   154 	INFO_PRINTF1(_L("Checking all methods"));

   155 	// Default constructor.

   156 	TBullet bullet;

   158 	INFO_PRINTF1(_L("Default constructor"));

   159 	test(0x2022==bullet.iCharacterCode);

   160 	test(bullet.iHeightInTwips==0);

   162 	INFO_PRINTF1(_L("==/!="));

   163 	TBullet bullet2;

   164 	test(bullet==bullet2);

   165 	test(!(bullet!=bullet2));

   167 	TBullet bullet3;

   168 	bullet3.iCharacterCode=45;

   169 	test(bullet!=bullet3);

   170 	test(!(bullet==bullet3));

   171 	}

   174 template<class S>

   175 void TestFormat<S>::CheckCParaFormatTabsEqual(TTabStop& aCheck,TTabStop& aControl)

   176 //

   177 // Check the 2 TTabStop structs are equal.

   178 //

   179 	{test(aCheck==aControl);}

   182 template<class S>

   183 void TestFormat<S>::CheckCParaFormatL()

   184 //

   185 //	Checks CParaFormat construction and methods.

   186 //

   187 	{

   188 	INFO_PRINTF1(_L("Checking all methods"));

   189 	CheckCParaFormatSpecialL();

   190 	__UHEAP_MARK;

   192 	TInt failRate;

   193 	CParaFormat* pp=NULL;

   194 	for (failRate=1;;failRate++)

   195 		{

   196 		__UHEAP_RESET;

   197 		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

   198 		__UHEAP_MARK;

   199 		TRAPD(ret,pp=CParaFormat::NewL());

   200 		if (ret!=KErrNone)

   201 			{

   202 			__UHEAP_MARKEND;

   203 			test(pp==NULL);

   204 			}

   205 		else

   206 			{

   207 			test(pp!=NULL);

   208 			delete pp;

   209 			__UHEAP_MARKEND;

   210 			break;

   211 			}

   212 		}

   213 	__UHEAP_RESET;

   218 	CParaFormat* format=CParaFormat::NewL();

   220 	INFO_PRINTF1(_L("Tab methods"));

   221 	TTabStop control[5];

   222 	control[4].iTwipsPosition=KMaxTUint32;

   223 	control[3].iTwipsPosition=8640;

   224 	control[2].iTwipsPosition=5760;

   225 	control[1].iTwipsPosition=2880;

   226  	control[0].iTwipsPosition=1;

   228 	control[0].iType=TTabStop::ERightTab;

   229 	control[1].iType=TTabStop::ECenteredTab;

   231 // Store the tabs.

   232 	test(format->TabCount()==0);

   233 	format->StoreTabL(control[4]);

   234 	test(format->TabCount()==1);

   235 	format->StoreTabL(control[2]);

   236 	test(format->TabCount()==2);

   237 	format->StoreTabL(control[1]);

   238 	test(format->TabCount()==3);

   239 	format->StoreTabL(control[3]);

   240 	test(format->TabCount()==4);

   241 	format->StoreTabL(control[0]);

   242 	test(format->TabCount()==5);

   244 // Read the tabs.

   245 	TTabStop buf;

   246 	TInt tc1=format->TabCount();

   247 	for (TInt count=0;count<tc1;count++)

   248 		{

   249 		buf=format->TabStop(count);

   250 		CheckCParaFormatTabsEqual(buf,control[count]);

   251 		}

   253 // RemoveAllTabs

   254 	format->RemoveAllTabs();

   255 	TInt tabCount=format->TabCount();

   256 	test(tabCount==0);

   258 // Remove the tabs.

   259 	format->RemoveTab(5760);

   260 	test(format->TabCount()==0);

   261 	format->RemoveTab(2880);

   262 	test(format->TabCount()==0);

   263 	format->RemoveTab(8640);

   264 	test(format->TabCount()==0);

   265 	format->RemoveTab(1);

   266 	test(format->TabCount()==0);

   267 	format->RemoveTab(KMaxTUint32);

   268 	test(format->TabCount()==0);

   270 	delete format;

   271 	format=NULL;

   272 	__UHEAP_MARKEND;

   273 	}

   276 template<class S>

   277 void TestFormat<S>::CheckCParaFormatSpecialL()

   278 //

   279 // Checks CParaFormat construction and methods.

   280 //

   281 	{

   282 	__UHEAP_MARK;

   283 	CParaFormat* format=CParaFormat::NewLC();

   284 	CParaFormat* newFormat=CParaFormat::NewLC();

   285 //	Tab functions

   286 	format->TabCount();

   287 	TTabStop tab;

   288 	format->StoreTabL(tab);

   289 	format->TabStop(0);

   290 	format->RemoveTab(0);

   291 	format->RemoveAllTabs();

   292 //	Border functions

   293 	TParaBorder testBorder;

   294 	format->RemoveAllBorders();

   295 	format->BordersPresent();

   296 	format->AllBordersEqual(*newFormat);

   297 	format->SetParaBorderL(CParaFormat::EParaBorderTop,testBorder);

   298 	format->IsBorderEqual(CParaFormat::EParaBorderBottom,*newFormat);

   299 	CleanupStack::PopAndDestroy(2);

   300 	format=NULL;

   301 	__UHEAP_MARKEND;

   302 	TInt ret;

   303 	TInt check=0;

   304 #ifdef _DEBUG

   305 	__UHEAP_MARK;

   306 	// Construction.

   307 	INFO_PRINTF1(_L("Construction failing on OOM"));

   308 	__UHEAP_FAILNEXT(1);

   309 	TRAP(ret,format=CParaFormat::NewL());

   310 	if (ret!=KErrNone)

   311 		check=1;

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

   313     // below test does not pass in platsim.

   314 //	test(check==1);

   315 #endif

   316 	INFO_PRINTF1(_L("Construction succeeding"));

   317 	check=0;

   318 	TRAP(ret,format=CParaFormat::NewL());

   319 	if (ret!=KErrNone)

   320 		check++;

   321 	test(check==0);

   322 	//

   323 	TLogicalRgb fillColor(TLogicalRgb::ESystemBackgroundColor);

   324 	test(format->iFillColor==fillColor);

   325 	test(format->iLanguage==0);

   326 	test(format->iLeftMarginInTwips==0);

   327 	test(format->iRightMarginInTwips==0);

   328 	test(format->iIndentInTwips==0);

   329 	test(format->iBorderMarginInTwips==0);

   330 	test(format->iSpaceBeforeInTwips==0);

   331 	test(format->iSpaceAfterInTwips==0);

   332 	test(format->iHorizontalAlignment==CParaFormat::ELeftAlign);

   333 	test(format->iVerticalAlignment==CParaFormat::EUnspecifiedAlign);

   334 	test(format->iKeepTogether==EFalse);

   335 	test(format->iKeepWithNext==EFalse);

   336 	test(format->iStartNewPage==EFalse);

   337 	test(format->iWidowOrphan==EFalse);

   338 	test(format->iWrap);

   339 	test(!format->BordersPresent());

   340 	test(format->iBullet==NULL);

   341 	test(format->iLineSpacingInTwips==200);

   342 	test(format->iLineSpacingControl==CParaFormat::ELineSpacingAtLeastInTwips);

   343 	test(format->iDefaultTabWidthInTwips==360);

   345 	INFO_PRINTF1(_L("Equality operator"));

   346 	CParaFormat* two=CParaFormat::NewL();

   347 	test(two->IsEqual(*format));

   348 	delete two;

   350 	INFO_PRINTF1(_L("Copy constructor"));

   351 	CParaFormat* three=CParaFormat::NewL(*two);

   352 	test(three->IsEqual(*two));

   353 	delete three;

   356 	// Destroy()

   357 	INFO_PRINTF1(_L("Destroy()"));

   358 	delete format;

   359 	format=NULL;

   360 	__UHEAP_MARKEND;

   361 	}

   364 template<class S>

   365 void TestFormat<S>::CheckTParaFormatMask()

   366 //

   367 // Checks TParaFormatMask construction and methods.

   368 //

   369 	{

   370 	__UHEAP_MARK;

   371 	TInt count=0;

   372 // All methods.

   373 	INFO_PRINTF1(_L("Checking all methods"));

   374 	TParaFormatMask mask;

   375 	mask.SetAttrib(EAttLeftMargin);

   376 	mask.AttribIsSet(EAttLeftMargin);

   377 	mask.ClearAttrib(EAttLeftMargin);

   378 	TParaFormatMask maskTemp;

   379 	test(maskTemp==mask);

   380 	test(!(maskTemp!=mask));

   382 // Construction.

   383 	INFO_PRINTF1(_L("Construction"));

   384 	TParaFormatMask mask1;

   385 	for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)

   386 		{

   387 		test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);

   388 		}

   391 // SetAttrib()

   392 	INFO_PRINTF1(_L("SetAttrib()"));

   393 	for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)

   394 		{

   395 		mask1.SetAttrib((TTextFormatAttribute)count);

   396 		}

   398 // ClearAttrib()

   399 	INFO_PRINTF1(_L("ClearAttrib()"));

   400 	for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)

   401 		{

   402 		mask1.ClearAttrib((TTextFormatAttribute)count);

   403 		}

   404 	for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)

   405 		{

   406 		test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);

   407 		}

   408 // AttribIsSet()

   409 	INFO_PRINTF1(_L("AttribIsSet()"));

   410 	// Already tested in the above.

   412 	INFO_PRINTF1(_L("SetAll()"));

   413 	TParaFormatMask mask2;

   414 	mask2.SetAll();  // sets border container but not individual borders.

   415  	for (count=EAttParaLanguage;count<EAttTabStop;count++)

   416 		{

   417 		test(mask2.AttribIsSet((TTextFormatAttribute)count));

   418 		}

   420 	INFO_PRINTF1(_L("ClearAll()"));

   421 	mask2.ClearAll();

   422  	for (count=EAttParaLanguage;count<EAttTabStop;count++)

   423 		{

   424 		test(mask2.AttribIsSet((TTextFormatAttribute)count)==EFalse);

   425 		}

   426 	mask2.SetAttrib(EAttLeftMargin);

   427 	test(mask2.AttribIsSet(EAttLeftMargin));

   429 	__UHEAP_MARKEND;

   430 	}

   433 template<class S>

   434 void TestFormat<S>::CheckFormatsEqual(TCharFormat& aControl,TCharFormatMask& aControlMask,TCharFormat& aCheck,TCharFormatMask& aMask)

   435 //

   436 // Checks that 2 TCharFormats are exactly equal.

   437 //

   438 	{

   439 	test(aControlMask==aMask);

   440 	test(aControl.IsEqual(aCheck,aMask));

   441 	}

   444 template<class S>

   445 void TestFormat<S>::CheckFormatsEqual(CParaFormat* aControl,CParaFormat* aCheck)

   446 //

   447 // Checks 2 CParaFormats are exactly equal.

   448 //

   449 	{test(aControl->IsEqual(*aCheck));}

   452 template<class S>

   453 void TestFormat<S>::CheckFormatsEqual(TParaFormatMask& aControl,TParaFormatMask& aCheck)

   454 //

   455 // Checks the guards are exactly the same.

   456 //

   457 	{test(aControl==aCheck);}

   460 template<class S>

   461 void TestFormat<S>::CheckCCharFormatLayerL()

   462 //

   463 // Checks CCharFormatLayer constructor and methods.

   464 //

   465 	{

   466 	__UHEAP_MARK;

   468 	TParaFormatMask mmm;

   469 	CParaFormatLayer* pL=CParaFormatLayer::NewL();

   470 	CParaFormatLayer* pL1=CParaFormatLayer::NewL(NULL,mmm);

   471 	mmm.SetAttrib(EAttLeftMargin);

   472 	CParaFormat ppp;

   473 	ppp.iLeftMarginInTwips=1000;

   474 	CParaFormatLayer* pL2=CParaFormatLayer::NewL(&ppp,mmm);

   476 	test(pL->IsEmpty());

   477 	test(pL1->IsEmpty());

   478 	test(!(pL2->IsEmpty()));

   480 	delete pL2;

   481 	delete pL1;

   482 	delete pL;

   484 	TCharFormat format1,format2,format3,formatCmp;

   485 	TCharFormatMask f1,f2,f3,fCmp;

   487 	TRgb Color1(10,10,10);

   488 	TRgb Color2(50,50,50);

   489 	TRgb hlColor1(3,4,5);

   491 	// Setup layer 1 values

   492 	format1.iFontPresentation.iTextColor=Color1;	f1.SetAttrib(EAttColor);

   493 	format1.iFontSpec.iHeight=1400;	f1.SetAttrib(EAttFontHeight);

   494 	format1.iFontSpec.iFontStyle.SetPosture(EPostureItalic);	f1.SetAttrib(EAttFontPosture);

   495 	format1.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript);	f1.SetAttrib(EAttFontPrintPos);

   496 	// Setup layer 2 values

   497 	format2.iFontPresentation.iHighlightColor=hlColor1; f2.SetAttrib(EAttFontHighlightColor);

   498 	format2.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightRounded;  f2.SetAttrib(EAttFontHighlightStyle);

   499 	format2.iFontPresentation.iStrikethrough=EStrikethroughOn;	f2.SetAttrib(EAttFontStrikethrough);

   500 	format2.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);	f2.SetAttrib(EAttFontStrokeWeight);

   501 	format2.iFontPresentation.iUnderline=EUnderlineOn;	f2.SetAttrib(EAttFontUnderline);

   502 	format2.iFontSpec.iTypeface.iName=(_L("Moffat"));

   503 	format2.iFontSpec.iTypeface.SetIsProportional(ETrue);

   504 	format2.iFontSpec.iTypeface.SetIsSerif(ETrue);

   505     format2.iFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   506 	f2.SetAttrib(EAttFontTypeface);

   507 	// Setup layer 3 values - should be ignored cos they're already present.

   508 	format3.iFontPresentation.iTextColor=Color2;	f3.SetAttrib(EAttColor);

   509 	format3.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightNormal;  f3.SetAttrib(EAttFontHighlightStyle);

   510 	format3.iFontSpec.iHeight=2800;	f3.SetAttrib(EAttFontHeight);

   511 	format3.iFontSpec.iFontStyle.SetPosture(EPostureUpright);	f3.SetAttrib(EAttFontPosture);

   512 	format3.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSuperscript);	f3.SetAttrib(EAttFontPrintPos);

   513 	format3.iFontPresentation.iStrikethrough=EStrikethroughOff;	f3.SetAttrib(EAttFontStrikethrough);

   514 	format3.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);	f3.SetAttrib(EAttFontStrokeWeight);

   515 	format3.iFontPresentation.iUnderline=EUnderlineOff;	f3.SetAttrib(EAttFontUnderline);

   516 	format3.iFontSpec.iTypeface.iName=(_L("Moon"));

   517 	format3.iFontSpec.iTypeface.SetIsProportional(EFalse);

   518 	format3.iFontSpec.iTypeface.SetIsSerif(EFalse);

   519 	f3.SetAttrib(EAttFontTypeface);

   520 	// Setup formatCmp values - the expected result of format layering.

   521 	formatCmp.iFontPresentation.iTextColor=Color1;	fCmp.SetAttrib(EAttColor);

   522 	formatCmp.iFontPresentation.iHighlightColor=hlColor1; fCmp.SetAttrib(EAttFontHighlightColor);

   523 	formatCmp.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightRounded;  fCmp.SetAttrib(EAttFontHighlightStyle);

   524 	formatCmp.iFontSpec.iHeight=1400;	fCmp.SetAttrib(EAttFontHeight);

   525 	formatCmp.iFontSpec.iFontStyle.SetPosture(EPostureItalic);	fCmp.SetAttrib(EAttFontPosture);

   526 	formatCmp.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript);	fCmp.SetAttrib(EAttFontPrintPos);

   527 	formatCmp.iFontPresentation.iStrikethrough=EStrikethroughOn;	fCmp.SetAttrib(EAttFontStrikethrough);

   528 	formatCmp.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);	fCmp.SetAttrib(EAttFontStrokeWeight);

   529 	formatCmp.iFontPresentation.iUnderline=EUnderlineOn;	fCmp.SetAttrib(EAttFontUnderline);

   530 	formatCmp.iFontSpec.iTypeface.iName=(_L("Moffat"));

   531 	formatCmp.iFontSpec.iTypeface.SetIsProportional(ETrue);

   532 	formatCmp.iFontSpec.iTypeface.SetIsSerif(ETrue);

   533     formatCmp.iFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   534 	fCmp.SetAttrib(EAttFontTypeface);

   535 	// Store the formats in char format layers

   536 	CCharFormatLayer* formatLayer3=CCharFormatLayer::NewL(format3,f3);

   537 	CCharFormatLayer* formatLayer2=CCharFormatLayer::NewL(format2,f2);

   538 	CCharFormatLayer* formatLayer1=CCharFormatLayer::NewL(format1,f1);

   539 	formatLayer1->SetBase(formatLayer2);

   540 	INFO_PRINTF1(_L("ChainCount()"));

   541 	test(formatLayer1->ChainCount()==2);

   542 	// Now read them in and compare them:

   543 	// First just the layers.

   544 	INFO_PRINTF1(_L("SenseL() - Sensing this layer only"));

   545 	TCharFormat result1;

   546 	TCharFormatMask result1Mask;

   547 	formatLayer1->Sense(result1,result1Mask);

   548 	CheckFormatsEqual(format1,f1,result1,result1Mask);

   550 	TCharFormat result2;

   551 	TCharFormatMask result2Mask;

   552 	formatLayer2->Sense(result2,result2Mask);

   553 	CheckFormatsEqual(format2,f2,result2,result2Mask);

   554 	test(result2.iFontSpec.iFontStyle.BitmapType() == format2.iFontSpec.iFontStyle.BitmapType());

   555 	test(result2.iFontSpec.iFontStyle.BitmapType() == EAntiAliasedGlyphBitmap);

   557 	// Now check the effective formats are correct

   558 	INFO_PRINTF1(_L("SenseEffectiveL() - utilising basedOn"));

   559 	TCharFormatMask dummy;

   560 	TCharFormat result3;

   561 	formatLayer1->SenseEffective(result3);

   562 	CheckFormatsEqual(format3,dummy,result3,dummy);

   564 	// Now check the effective formats are correct

   565 	// The result should be the same as above,

   566 	// since all these values are present in the resultant TCharFormat.

   567 	// Ie, checking that overlapping attributes in a lower layer are not taken.

   568 	INFO_PRINTF1(_L("SenseEffectiveL() - checking overlapping attributes are ignored"));

   569 	// Add another layer of formatting by implementing the next based on link.

   570 	formatLayer2->SetBase(formatLayer3);

   571 		INFO_PRINTF1(_L("ChainCount()"));

   572 		test(formatLayer1->ChainCount()==3);

   573 		test(formatLayer2->ChainCount()==2);

   574 		test(formatLayer3->ChainCount()==1);

   575 	TCharFormat result4;

   576 	formatLayer1->SenseEffective(result4);

   577 	CheckFormatsEqual(format3,dummy,result4,dummy);

   579 	delete formatLayer1;

   580 	delete formatLayer2;

   581 	delete formatLayer3;

   582 	__UHEAP_MARKEND;

   583 	}

   586 template<class S>

   587 void TestFormat<S>::CheckCParaFormatLayerRestL()

   588 //

   589 // Checks combinations of set and sense with format layering.

   590 //

   591 	{

   592 	__UHEAP_MARK;

   593 	CParaFormat* format1=CParaFormat::NewL();

   594 	TParaFormatMask format1Mask;

   596 	CParaFormat* format2=CParaFormat::NewL();

   597 	TParaFormatMask format2Mask;

   599 	CParaFormat* format3=CParaFormat::NewL();

   601 	CParaFormat* format4=CParaFormat::NewL();

   602 	TParaFormatMask format4Mask;

   604 	TRgb Color1(10,10,10);

   605 	TRgb Color2(50,50,50);

   606 	TRgb Color3(100,100,100);

   607 	TRgb Color4(150,150,150);

   609 	TTabStop tab1layer1,tab2layer1,tab3layer1;

   610 	tab1layer1.iTwipsPosition=2520; tab1layer1.iType=TTabStop::ECenteredTab;

   611 	tab2layer1.iTwipsPosition=3960; tab2layer1.iType=TTabStop::ERightTab;

   612 	tab3layer1.iTwipsPosition=11160;tab3layer1.iType=TTabStop::ELeftTab;

   613 	TTabStop tab1layer2,tab2layer2,tab3layer2;

   614 	tab1layer2.iTwipsPosition=2160; tab1layer2.iType=TTabStop::ENullTab;

   615 	tab2layer2.iTwipsPosition=3600; tab2layer2.iType=TTabStop::ENullTab;

   616 	tab3layer2.iTwipsPosition=10080;tab3layer2.iType=TTabStop::ENullTab;

   617 	TTabStop tab1layer3,tab2layer3,tab3layer3;

   618 	tab1layer3.iTwipsPosition=2160; tab1layer3.iType=TTabStop::ECenteredTab;

   619 	tab2layer3.iTwipsPosition=3600; tab2layer3.iType=TTabStop::ERightTab;

   620 	tab3layer3.iTwipsPosition=10080;tab3layer3.iType=TTabStop::ELeftTab;

   621 	// Setup layer 1 values.

   622 	format1->iFillColor=Color1; format1Mask.SetAttrib(EAttFillColor);

   623 	format1->iLeftMarginInTwips=1440; format1Mask.SetAttrib(EAttLeftMargin);

   624 	format1->iRightMarginInTwips=7000; format1Mask.SetAttrib(EAttRightMargin);

   625 	format1->iIndentInTwips=1500; format1Mask.SetAttrib(EAttIndent);

   626 	format1->iHorizontalAlignment=CParaFormat::ERightAlign; format1Mask.SetAttrib(EAttAlignment);

   627 	format1->iVerticalAlignment=CParaFormat::EBottomAlign; format1Mask.SetAttrib(EAttVerticalAlignment);

   628 	format1->iLineSpacingInTwips=12; format1Mask.SetAttrib(EAttLineSpacing);

   629 	format1->iSpaceBeforeInTwips=6; format1Mask.SetAttrib(EAttSpaceBefore);

   630 	format1->iSpaceAfterInTwips=7; format1Mask.SetAttrib(EAttSpaceAfter);

   631 	format1->iKeepTogether=ETrue; format1Mask.SetAttrib(EAttKeepTogether);

   632 	format1->iKeepWithNext=ETrue; format1Mask.SetAttrib(EAttKeepWithNext);

   633 	format1->iStartNewPage=ETrue; format1Mask.SetAttrib(EAttStartNewPage);

   634 	format1->iWidowOrphan=ETrue; format1Mask.SetAttrib(EAttWidowOrphan);

   635 	format1->iWrap=EFalse; format1Mask.SetAttrib(EAttWrap);

   636 	format1->iDefaultTabWidthInTwips=2880; format1Mask.SetAttrib(EAttDefaultTabWidth);

   637 	format1->StoreTabL(tab1layer1); format1->StoreTabL(tab2layer1); format1->StoreTabL(tab3layer1);

   638 	format1Mask.SetAttrib(EAttTabStop);

   639 	// Setup format 2 values.

   640 	TParaBorder topBorder;

   641 	topBorder.iLineStyle=TParaBorder::ESolid;

   642 	topBorder.iThickness=1;

   643 	topBorder.iAutoColor=ETrue;

   644 	topBorder.iColor=Color1;

   645 	format2->SetParaBorderL(CParaFormat::EParaBorderTop,topBorder);

   646 	format2Mask.SetAttrib(EAttTopBorder);

   647 	//

   648 	TParaBorder bottomBorder;

   649 	bottomBorder.iLineStyle=TParaBorder::ESolid;

   650 	bottomBorder.iThickness=1;

   651 	bottomBorder.iAutoColor=ETrue;

   652 	bottomBorder.iColor=Color2;

   653 	format2->SetParaBorderL(CParaFormat::EParaBorderBottom,bottomBorder);

   654 	format2Mask.SetAttrib(EAttBottomBorder);

   655 	//

   656 	TParaBorder leftBorder;

   657 	leftBorder.iLineStyle=TParaBorder::ESolid;

   658 	leftBorder.iThickness=1;

   659 	leftBorder.iAutoColor=ETrue;

   660 	leftBorder.iColor=Color3;

   661 	format2->SetParaBorderL(CParaFormat::EParaBorderLeft,leftBorder);

   662 	format2Mask.SetAttrib(EAttLeftBorder);

   663 	//

   664 	TParaBorder rightBorder;

   665 	rightBorder.iLineStyle=TParaBorder::ESolid;

   666 	rightBorder.iThickness=1;

   667 	rightBorder.iAutoColor=ETrue;

   668 	rightBorder.iColor=Color4;

   669 	format2->SetParaBorderL(CParaFormat::EParaBorderRight,rightBorder);

   670 	format2Mask.SetAttrib(EAttRightBorder);

   671 	//

   672 	format2->StoreTabL(tab1layer2); format2->StoreTabL(tab2layer2); format2->StoreTabL(tab3layer2);

   673 	format2Mask.SetAttrib(EAttTabStop);

   674 	format2->iBullet=new(ELeave)TBullet;	format2Mask.SetAttrib(EAttBullet);

   675 	format2->iBullet->iHeightInTwips=200;

   676 	format2->iBullet->iCharacterCode=202;

   677 	format2->iBullet->iTypeface.iName=(_L("Symbol"));

   678 	format2->iBullet->iTypeface.SetIsProportional(ETrue);

   679 	format2->iBullet->iTypeface.SetIsSerif(ETrue);

   680 	// Setup format 3 values - The resulting format after hunting based on links.

   681 	format3->iFillColor=Color1;

   682 	format3->iLeftMarginInTwips=1440;

   683 	format3->iRightMarginInTwips=7000;

   684 	format3->iIndentInTwips=1500;

   685 	format3->iHorizontalAlignment=CParaFormat::ERightAlign;

   686 	format3->iVerticalAlignment=CParaFormat::EBottomAlign;

   687 	format3->iLineSpacingInTwips=12;

   688 	format3->iSpaceBeforeInTwips=6;

   689 	format3->iSpaceAfterInTwips=7;

   690 	format3->iKeepTogether=ETrue;

   691 	format3->iKeepWithNext=ETrue;

   692 	format3->iStartNewPage=ETrue;

   693 	format3->iWidowOrphan=ETrue;

   694 	format3->iWrap=EFalse;

   695 	format3->iDefaultTabWidthInTwips=2880;

   696   	TParaBorder top;

   697 	top.iLineStyle=TParaBorder::ESolid;

   698 	top.iThickness=1;

   699 	top.iAutoColor=ETrue;

   700 	top.iColor=Color1;

   701 	TParaBorder bottom;

   702 	bottom.iLineStyle=TParaBorder::ESolid;

   703 	bottom.iThickness=1;

   704 	bottom.iAutoColor=ETrue;

   705 	bottom.iColor=Color2;

   706 	TParaBorder left;

   707 	left.iLineStyle=TParaBorder::ESolid;

   708 	left.iThickness=1;

   709 	left.iAutoColor=ETrue;

   710 	left.iColor=Color3;

   711 	TParaBorder right;

   712 	right.iThickness=1;

   713 	right.iLineStyle=TParaBorder::ESolid;

   714 	right.iAutoColor=ETrue;

   715 	right.iColor=Color4;

   716 	format3->SetParaBorderL(CParaFormat::EParaBorderTop,top);

   717 	format3->SetParaBorderL(CParaFormat::EParaBorderBottom,bottom);

   718 	format3->SetParaBorderL(CParaFormat::EParaBorderLeft,left);

   719 	format3->SetParaBorderL(CParaFormat::EParaBorderRight,right);

   720 	//

   721 	format3->StoreTabL(tab1layer1); format3->StoreTabL(tab2layer1); format3->StoreTabL(tab3layer1);

   722 //	format3->StoreTabL(tab1layer2); format3->StoreTabL(tab2layer2); format3->StoreTabL(tab3layer2);

   723 	format3->iBullet=new(ELeave)TBullet;

   724 	format3->iBullet->iHeightInTwips=200;

   725 	format3->iBullet->iCharacterCode=202;

   726 	format3->iBullet->iTypeface.iName=(_L("Symbol"));

   727 	format3->iBullet->iTypeface.SetIsProportional(ETrue);

   728 	format3->iBullet->iTypeface.SetIsSerif(ETrue);

   729 	// Setup format 4 values - The resulting format after hunting based on links.

   730 	// and ignoring all these attributes since they are already set in the CParaFormat.

   731  	format4->iLeftMarginInTwips=6666; format4Mask.SetAttrib(EAttLeftMargin);

   732 	format4->iRightMarginInTwips=6666; format4Mask.SetAttrib(EAttRightMargin);

   733 	format4->iIndentInTwips=6666; format4Mask.SetAttrib(EAttIndent);

   734 	format4->iHorizontalAlignment=CParaFormat::ERightAlign; format4Mask.SetAttrib(EAttAlignment);

   735 	format4->iLineSpacingInTwips=6666; format4Mask.SetAttrib(EAttLineSpacing);

   736 	format4->iSpaceBeforeInTwips=6666; format4Mask.SetAttrib(EAttSpaceBefore);

   737 	format4->iSpaceAfterInTwips=6666; format4Mask.SetAttrib(EAttSpaceAfter);

   738 	format4->iKeepTogether=EFalse; format4Mask.SetAttrib(EAttKeepTogether);

   739 	format4->iKeepWithNext=EFalse; format4Mask.SetAttrib(EAttKeepWithNext);

   740 	format4->iStartNewPage=EFalse; format4Mask.SetAttrib(EAttStartNewPage);

   741 	format4->iWidowOrphan=EFalse; format4Mask.SetAttrib(EAttWidowOrphan);

   742 	format4->iDefaultTabWidthInTwips=6666; format4Mask.SetAttrib(EAttDefaultTabWidth);

   743 	TParaBorder zTop;

   744 	zTop.iLineStyle=TParaBorder::EDashed;

   745 	format4Mask.SetAttrib(EAttTopBorder);

   746 	zTop.iAutoColor=EFalse;

   747 	TParaBorder zBottom;

   748 	zBottom.iLineStyle=TParaBorder::EDashed;

   749 	format4Mask.SetAttrib(EAttBottomBorder);

   750 	zBottom.iAutoColor=EFalse;

   751 	TParaBorder zLeft;

   752 	zLeft.iLineStyle=TParaBorder::EDashed;

   753 	format4Mask.SetAttrib(EAttLeftBorder);

   754 	zLeft.iAutoColor=EFalse;

   755 	TParaBorder zRight;

   756 	zRight.iLineStyle=TParaBorder::EDashed;

   757 	format4Mask.SetAttrib(EAttRightBorder);

   758 	zRight.iAutoColor=EFalse;

   759 	format4->SetParaBorderL(CParaFormat::EParaBorderTop,zTop);

   760 	format4->SetParaBorderL(CParaFormat::EParaBorderBottom,zBottom);

   761 	format4->SetParaBorderL(CParaFormat::EParaBorderLeft,zLeft);

   762 	format4->SetParaBorderL(CParaFormat::EParaBorderRight,zRight);

   763 	//

   764 	format4->StoreTabL(tab1layer3); format4->StoreTabL(tab2layer3); format4->StoreTabL(tab3layer3);

   765 	format4Mask.SetAttrib(EAttTabStop);

   766 	format4->iBullet=new(ELeave)TBullet; format4Mask.SetAttrib(EAttBullet);

   767 	format4->iBullet->iHeightInTwips=240;

   768 	format4->iBullet->iCharacterCode=201;

   769 	format4->iBullet->iTypeface.iName=(_L("Windings"));

   770 	format4->iBullet->iTypeface.SetIsSerif(ETrue);

   771 	format4->iBullet->iTypeface.SetIsProportional(EFalse);

   772 	// Store the formats in para format layers

   773 	CParaFormatLayer* formatLayer4=CParaFormatLayer::NewL(format4,format4Mask);

   775 	CParaFormatLayer* formatLayer2=CParaFormatLayer::NewL(format2,format2Mask);

   777 	CParaFormatLayer* formatLayer=CParaFormatLayer::NewL(format1,format1Mask);

   778 	formatLayer->SetBase(formatLayer2);

   780 	// Now read them in and compare them:

   781 	// First just the layers.

   782 	INFO_PRINTF1(_L("SenseL() - Sensing this layer only"));

   783 	CParaFormat* formatResult1=CParaFormat::NewL();

   784 	TParaFormatMask formatResult1Mask;

   785 	formatLayer->SenseL(formatResult1,formatResult1Mask);

   786 	CheckFormatsEqual(format1,formatResult1);

   787 	CheckFormatsEqual(format1Mask,formatResult1Mask);

   788 	delete formatResult1;

   790 	formatResult1=CParaFormat::NewL();

   791 	formatResult1Mask.ClearAll();

   792 	formatLayer2->SenseL(formatResult1,formatResult1Mask);

   793 	CheckFormatsEqual(format2,formatResult1);

   794 	CheckFormatsEqual(format2Mask,formatResult1Mask);

   795 	delete formatResult1;

   797 	// Now check the effective formats are correct

   798 	INFO_PRINTF1(_L("SenseEffectiveL() - utilising basedOn"));

   799 	CParaFormat* formatResult2=CParaFormat::NewL();

   800 	formatLayer->SenseEffectiveL(formatResult2);

   801 	CheckFormatsEqual(format3,formatResult2);

   802 	delete formatResult2;

   804 	// Now check the effective formats are correct

   805 	// The result should be the same as above,

   806 	// since all these values are present in the resultant CParaFormat.

   807 	// Ie, checking that overlapping attributes in a lower layer are not taken.

   808 	INFO_PRINTF1(_L("SenseEffectiveL() - checking overlapping attributes are ignored"));

   809 	// Add another layer of formatting by implementing the next based on link.

   810 	formatLayer2->SetBase(formatLayer4);

   811 	formatResult2=CParaFormat::NewL();

   812 	formatLayer->SenseEffectiveL(formatResult2);

   813 	CheckFormatsEqual(format3,formatResult2);

   814 	delete formatResult2;

   816 	// Test ChainCount() method

   817 	INFO_PRINTF1(_L("ChainCount()"));

   818 	test(formatLayer4->ChainCount()==1);

   819 	test(formatLayer2->ChainCount()==2);

   820 	test(formatLayer->ChainCount()==3);

   822 	// Now clean up.

   823 	delete formatLayer;

   824 	delete formatLayer2;

   825 	delete formatLayer4;

   826 	//formatLayer3 does not exist, so each can use it's own same numbered format.

   827 	delete format1;

   828 	delete format2;

   829 	delete format3;

   830 	delete format4;

   831 	__UHEAP_MARKEND;

   832 	}

   835 LOCAL_C void CheckBulletInheritance()

   836 //

   837 // Checks correct inheritance of bullets.

   838 //

   839 	{

   840 	INFO_PRINTF1(_L("Testing bullet inheritance"));

   841 	__UHEAP_MARK;

   843 	CParaFormatLayer* baseLayer=CParaFormatLayer::NewL();

   844 	CParaFormatLayer* specificLayer=CParaFormatLayer::NewL();

   845 	specificLayer->SetBase(baseLayer);

   846 	CParaFormat* paraFormat=CParaFormat::NewLC();

   847 	paraFormat->iBullet=new(ELeave) TBullet;

   848 	paraFormat->iBullet->iHeightInTwips=200;

   849 	paraFormat->iBullet->iCharacterCode=202;

   850 	TParaFormatMask paraMask;

   851 	paraMask.SetAttrib(EAttBullet);

   852 	specificLayer->SetL(paraFormat,paraMask);

   853 	//

   854 	// specific bullet over null inherited

   855 	INFO_PRINTF1(_L("Specific bullet over null inherited"));

   856 	CParaFormat* sensed=CParaFormat::NewLC();

   857 	specificLayer->SenseEffectiveL(sensed);

   858 	test(sensed->iBullet!=NULL);

   859 	test(sensed->iBullet->iHeightInTwips==200);

   860 	CleanupStack::PopAndDestroy();  // sensed

   861 	//

   862 	// null bullet over inherited

   863 	INFO_PRINTF1(_L("Null bullet over inherited"));

   864 	baseLayer->Reset();

   865 	specificLayer->Reset();

   866 	baseLayer->SetL(paraFormat,paraMask);

   867 	CParaFormat* empty=CParaFormat::NewLC();

   868 	TParaFormatMask temp;

   869 	temp.SetAttrib(EAttBullet);

   870 	specificLayer->SetL(empty,temp);

   871 	CleanupStack::PopAndDestroy();  // empty

   872 	sensed=CParaFormat::NewLC();

   873 	specificLayer->SenseEffectiveL(sensed);

   874 	CleanupStack::PopAndDestroy();  // sensed

   875 //	test(sensed->iBullet==NULL);

   876 	//

   877 	// non-null bullet over inherited bullet

   878 	INFO_PRINTF1(_L("Non-Null bullet over inherited"));

   879 	specificLayer->Reset();

   880 	paraFormat->iBullet->iHeightInTwips=1000;

   881 	specificLayer->SetL(paraFormat,paraMask);

   882 	sensed=CParaFormat::NewLC();

   883 	specificLayer->SenseEffectiveL(sensed);

   884 	test(sensed->iBullet!=NULL);

   885 	test(sensed->iBullet->iHeightInTwips==1000);

   886 	CleanupStack::PopAndDestroy();  // sensed

   888 	CleanupStack::PopAndDestroy();  // paraFormat.

   889 	delete specificLayer;

   890 	delete baseLayer;

   892 	__UHEAP_MARKEND;

   893 	}

   896 template<class S>

   897 void TestFormat<S>::CheckCParaFormatLayerL()

   898 //

   899 // Checks CParaFormatLayer construction and methods.

   900 //

   901 	{

   902 	__UHEAP_MARK;

   905 	TInt ret=0;

   906 	TInt check=0;

   907 	CParaFormatLayer* layer0=NULL;

   909 	INFO_PRINTF1(_L("Constructor"));

   910 #ifdef _DEBUG

   911 	INFO_PRINTF1(_L("Failing on OOM"));

   912 	__UHEAP_FAILNEXT(1);

   913 	TRAP(ret,layer0=CParaFormatLayer::NewL());

   914 	if (ret!=KErrNone)

   915 		check++;

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

   917     // below test does not pass in platsim.

   918 //	test(check>0);

   919 #endif

   921 	INFO_PRINTF1(_L("Succeeding"));

   922 	check=0;

   923 	TRAP(ret,layer0=CParaFormatLayer::NewL());

   924 	if (ret!=KErrNone)

   925 		check++;

   926 	test(check==0);

   927 	delete layer0;

   929 // Set/Sense Default Para Format.

   930 	INFO_PRINTF1(_L("Set/Sense Default ParaFormat"));

   931 	CParaFormat* defaultFormat=CParaFormat::NewL();

   933 	//to test EAttParaLanguageX

   934 	defaultFormat->iLanguage |= 0x100;

   936 	//set iBullet as a valid bullet to test EAttBullet and EAttBulletX

   937 	defaultFormat->iBullet=new(ELeave)TBullet;

   938 	defaultFormat->iBullet->iStyle = TBullet::EBulletStyle;

   939 	defaultFormat->iBullet->iHeightInTwips = 1;

   941 	TParaFormatMask defaultGuard;

   942 	defaultGuard.SetAttrib(EAttParaLanguage);

   943 	defaultGuard.SetAttrib(EAttBullet);

   944 	defaultGuard.SetAttrib(EAttLeftMargin);

   945 	defaultGuard.SetAttrib(EAttRightMargin);

   946 	defaultGuard.SetAttrib(EAttIndent);

   947 	defaultGuard.SetAttrib(EAttAlignment);

   948 	defaultGuard.SetAttrib(EAttLineSpacing);

   949 	defaultGuard.SetAttrib(EAttLineSpacingControl);

   950 	defaultGuard.SetAttrib(EAttSpaceBefore);

   951 	defaultGuard.SetAttrib(EAttSpaceAfter);

   952 	defaultGuard.SetAttrib(EAttKeepTogether);

   953 	defaultGuard.SetAttrib(EAttKeepWithNext);

   954 	defaultGuard.SetAttrib(EAttStartNewPage);

   955 	defaultGuard.SetAttrib(EAttWidowOrphan);

   956 	defaultGuard.SetAttrib(EAttBorderMargin);

   957 	defaultGuard.SetAttrib(EAttDefaultTabWidth);

   959 	CParaFormat* buffer1=CParaFormat::NewL();

   960 	TParaFormatMask bufferGuard1;

   961 	CParaFormat* buffer2=CParaFormat::NewL();

   963 	CParaFormatLayer* testing1=CParaFormatLayer::NewL();

   964 	testing1->SetL(defaultFormat,defaultGuard);

   965 	testing1->SenseL(buffer1,bufferGuard1);

   966 	testing1->SenseEffectiveL(buffer2);

   968 	test(defaultFormat->IsEqual(*buffer1));

   969 	test(defaultFormat->IsEqual(*buffer2));

   970 	CheckFormatsEqual(defaultGuard,bufferGuard1);

   972 	delete testing1;

   974 	delete defaultFormat;

   975 	delete buffer1;

   976 	delete buffer2;

   978 	CheckCParaFormatLayerRestL();

   979 	__UHEAP_MARKEND;

   980 	}

   983 template<class S>

   984 void TestFormat<S>::CheckTCharFormat()

   985 //

   986 // Checks the TCharFormat construction.

   987 //

   988 	{

   989 	__UHEAP_MARK;

   990 // All methods

   991 	INFO_PRINTF1(_L("Constructor"));

   992 	TCharFormat format;

   993 	test(format.iLanguage==0);

   995 	INFO_PRINTF1(_L("Constructor with arguments"));

   996 	TInt height=240;

   997 	TBuf<32> name=_S("arial");

   998 	TCharFormat format1(name,height);

   999 	format1.iFontSpec.iTypeface.SetAttributes(TTypeface::EProportional|TTypeface::ESerif);

  1000 	TCharFormat control;

  1001 	control.iFontSpec.iHeight=240;

  1002 	control.iFontSpec.iTypeface.iName=_S("arial");

  1003 	test(format1.IsEqual(control));

  1005 	__UHEAP_MARKEND;

  1006 	}

  1009 template<class S>

  1010 void TestFormat<S>::CheckTCharFormatMask()

  1011 //

  1012 // Checks TCharFormatMask construction and methods.

  1013 //

  1014 	{

  1015 	__UHEAP_MARK;

  1016 // All methods.

  1017 	TInt count=0;

  1018 	INFO_PRINTF1(_L("Checking all methods"));

  1019 	TCharFormatMask mask;

  1020 	mask.SetAttrib(EAttFontHeight);

  1021 	mask.AttribIsSet(EAttFontHeight);

  1022 	mask.ClearAttrib(EAttFontHeight);

  1023 // Construction.

  1024 	INFO_PRINTF1(_L("Construction"));

  1025 	TCharFormatMask mask1;

  1026 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1027 		{

  1028 		test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);

  1029 		}

  1030 // SetAttrib()

  1031 	INFO_PRINTF1(_L("SetAttrib()"));

  1032 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1033 		{

  1034 		mask1.SetAttrib((TTextFormatAttribute)count);

  1035 		}

  1036 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1037 		{

  1038 		test(mask1.AttribIsSet((TTextFormatAttribute)count));

  1039 		}

  1040 // ClearAttrib()

  1041 	INFO_PRINTF1(_L("ClearAttrib()"));

  1042 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1043 		{

  1044 		mask1.ClearAttrib((TTextFormatAttribute)count);

  1045 		}

  1046 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1047 		{

  1048 		test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);

  1049 		}

  1050 // AttribIsSet()

  1051 	INFO_PRINTF1(_L("AttribIsSet()"));

  1052 	// Already tested in the above.

  1053 	INFO_PRINTF1(_L("SetAll()"));

  1054 	TCharFormatMask mask2;

  1055 	mask2.SetAll();

  1056 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1057 		{

  1058 		test(mask2.AttribIsSet((TTextFormatAttribute)count));

  1059 		}

  1060 	INFO_PRINTF1(_L("ClearAll()"));

  1061 	mask2.ClearAll();

  1062 	for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)

  1063 		{

  1064 		test(mask2.AttribIsSet((TTextFormatAttribute)count)==EFalse);

  1065 		}

  1066 	__UHEAP_MARKEND;

  1067 	}

  1070 template<class S>

  1071 void TestFormat<S>::CheckAllClassesL()

  1072 //

  1073 // Check all classes and structs exist.

  1074 //

  1075 	{

  1076 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-LEGACY-T_FMT-0001 TTabStop "));

  1077 	CheckTTabStop();

  1079 	INFO_PRINTF1(_L("TParaBorder"));

  1080 	CheckTParaBorder();

  1082 	INFO_PRINTF1(_L("TBullet"));

  1083 	CheckTBullet();

  1085 	INFO_PRINTF1(_L("CParaFormat"));

  1086 	CheckCParaFormatL();

  1088 	INFO_PRINTF1(_L("TParaFormatMask"));

  1089 	CheckTParaFormatMask();

  1091 	INFO_PRINTF1(_L("CParaFormatLayer"));

  1092 	CheckCParaFormatLayerL();

  1094 	INFO_PRINTF1(_L("TCharFormat"));

  1095 	CheckTCharFormat();

  1097 	INFO_PRINTF1(_L("TCharFormatMask"));

  1098 	CheckTCharFormatMask();

  1100 	INFO_PRINTF1(_L("CCharFormatLayer"));

  1101 	CheckCCharFormatLayerL();

  1103 	}

  1106 LOCAL_C void TestSettingNullTabsL()

  1107 // Tests setting null tabs into a para format with tab stops.

  1108 //

  1109 	{

  1110 	INFO_PRINTF1(_L("Setting Null Tabs"));

  1112 	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();

  1113 	CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();

  1114 	//

  1115 	CRichText* text=CRichText::NewL(paraLayer,charLayer);

  1116 	//

  1117 	// Set tabs in the first paragraph.

  1118 	CParaFormat* paraFormat=CParaFormat::NewLC();

  1119 	TTabStop tabA;

  1120 		tabA.iTwipsPosition=100;

  1121 		tabA.iType=TTabStop::ELeftTab;

  1122 	TTabStop tabB;

  1123 		tabB.iTwipsPosition=200;

  1124 		tabB.iType=TTabStop::ELeftTab;

  1125 	TTabStop tabC;

  1126 		tabC.iTwipsPosition=300;

  1127 		tabC.iType=TTabStop::ERightTab;

  1128 	paraFormat->StoreTabL(tabA);

  1129 	paraFormat->StoreTabL(tabB);

  1130 	paraFormat->StoreTabL(tabC);

  1131 	TParaFormatMask paraMask;

  1132 	paraMask.SetAttrib(EAttTabStop);

  1133 	text->ApplyParaFormatL(paraFormat,paraMask,0,0);

  1134 	CleanupStack::PopAndDestroy();  // paraFormat

  1135 	//

  1136 	// Test that the tabs have been stored.

  1137 	CParaFormat* result=CParaFormat::NewLC();

  1138 	TParaFormatMask resultMask;

  1139 	text->GetParagraphFormatL(result,0);

  1140 	test(result->TabCount()==3);

  1141 	//

  1142 	// Now set zero tabs

  1143 	text->InsertL(0,CEditableText::EParagraphDelimiter);

  1144 	CParaFormat* newFormat=CParaFormat::NewLC();

  1145 	TParaFormatMask newMask;

  1146 	newMask.SetAttrib(EAttTabStop);

  1147 	text->ApplyParaFormatL(newFormat,newMask,1,0);

  1148 	CleanupStack::PopAndDestroy();  // newFormat

  1149 	//

  1150 	// Test how many tabs we have in the new paragraph

  1151 	CleanupStack::PopAndDestroy();  // result

  1152 	result=CParaFormat::NewLC();

  1153 	resultMask.ClearAll();

  1154 	text->GetParagraphFormatL(result,1);

  1155 	test(result->TabCount()==0);

  1156 	CleanupStack::PopAndDestroy();  // result

  1157 	//

  1158 	// Cleanup

  1159 	delete text;

  1160 	delete paraLayer;

  1161 	delete charLayer;

  1162 	}

  1165 LOCAL_C void TestFormatLayerResetL()

  1166 // Test CFormatLayer::Reset();

  1167 //

  1168 	{

  1169 	INFO_PRINTF1(_L("CFormatLayer::Reset()"));

  1171 	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();

  1172 	TCharFormat charFormat;

  1173 	TCharFormatMask charFormatMask;

  1174 	charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

  1175 	charFormat.iFontSpec.iFontStyle.SetPosture(EPostureItalic);

  1176 	charFormat.iFontPresentation.iStrikethrough=EStrikethroughOn;

  1177 	charFormat.iFontPresentation.iUnderline=EUnderlineOn;

  1178 	charFormatMask.SetAll();

  1179 	charLayer->SetL(charFormat,charFormatMask);

  1180 	//

  1181 	TCharFormat formatOne;

  1182 	TCharFormatMask formatOneMask;

  1183 	charLayer->Sense(formatOne,formatOneMask);

  1184 	test(formatOne.iFontSpec.iFontStyle.StrokeWeight()==EStrokeWeightBold);

  1185 	//

  1186 	charLayer->Reset();

  1187 	//

  1188 	TCharFormat result;

  1189 	TCharFormatMask resultMask;

  1190 	charLayer->Sense(result,resultMask);

  1191 	//

  1192 	TCharFormat comparator;

  1193 	test(result.IsEqual(comparator));

  1194 	//

  1195 	delete charLayer;

  1196 	}

  1198 CT_FMT::CT_FMT()

  1199     {

  1200     SetTestStepName(KTestStep_T_FMT);

  1201     pTestStep = this;

  1202     }

  1204 TVerdict CT_FMT::doTestStepL()

  1205     {

  1206     SetTestStepResult(EFail);

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

  1209     INFO_PRINTF1(_L("TFormat Test Code"));

  1210     TestFormat<TText>* fmt=new(ELeave) TestFormat<TText>;

  1211     TRAPD(ret1, fmt->CheckAllClassesL());

  1212     TRAPD(ret2, TestFormatLayerResetL());

  1213     TRAPD(ret3, TestSettingNullTabsL());

  1214     TRAPD(ret4, CheckBulletInheritance());

  1216     __UHEAP_MARK;

  1217     delete(fmt);

  1218     fmt=NULL;

  1219     __UHEAP_MARKEND;

  1221     delete cleanup;

  1223     if (ret1 == KErrNone && ret2 == KErrNone && ret3 == KErrNone && ret4 == KErrNone)

  1224         {

  1225         SetTestStepResult(EPass);

  1226         }

  1228     return TestStepResult();

  1229     }

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