--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textrendering/texthandling/ttext/T_FMT.CPP Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,1226 @@
+/*
+* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include <e32test.h>
+#include <txtfmlyr.h>
+#include <txtrich.h>
+#include <txtfrmat.h>
+#include <gdi.h>
+
+LOCAL_D RTest test(_L("TFormat Test Code"));
+
+template<class S>
+class TestFormat
+ {
+public:
+ void CheckAllClassesL();
+ void CheckTTabStop();
+ void CheckTParaBorder();
+ void CheckTBullet();
+ void CheckCParaFormatL();
+ void CheckCParaFormatSpecialL();
+ void CheckCParaFormatTabsEqual(TTabStop& aChecl,TTabStop& aControl);
+ void CheckTParaFormatMask();
+ void CheckCParaFormatLayerL();
+ void CheckCParaFormatLayerRestL();
+ void CheckTCharFormat();
+ void CheckTCharFormatMask();
+ void CheckCCharFormatLayerL();
+ void CheckFormatsEqual(CParaFormat* aControl,CParaFormat* aCheck);
+ void CheckFormatsEqual(TCharFormat& aControl,TCharFormatMask& aControlMask,TCharFormat& aCheck,TCharFormatMask& aMask);
+ void CheckFormatsEqual(TParaFormatMask& aControl,TParaFormatMask& aCheck);
+ void CheckFormatsEqual(TCharFormatMask& aControl,TCharFormatMask& aCheck);
+ };
+
+
+template<class S>
+void TestFormat<S>::CheckTTabStop()
+//
+// Checks TTabStop construction and methods.
+//
+ {
+ test.Start(_L("Checking all methods"));
+
+ // Default constructor.
+ TTabStop tab1;
+ // Assignment operator.
+ TTabStop tab3;
+ tab3=tab1;
+
+ test.Next(_L("Default constructor"));
+ test(tab1.iTwipsPosition==0);
+ if (tab1.iType==TTabStop::ELeftTab)
+ test.Printf(_L("\nleft tab - %d\n"),tab1.iType);
+ else if (tab1.iType==TTabStop::ECenteredTab)
+ test.Printf(_L("\ncentered tab - %d\n"),tab1.iType);
+ else if (tab1.iType==TTabStop::ERightTab)
+ test.Printf(_L("\nright tab - %d\n"),tab1.iType);
+ else if (tab1.iType==TTabStop::ENullTab)
+ test.Printf(_L("\nnull tab - %d\n"),tab1.iType);
+ else
+ test.Printf(_L("\nsomething completely different - %d \n"),tab1.iType);
+ test(tab1.iType==TTabStop::ELeftTab);
+// test.Getch();
+
+ test.Next(_L("Copy constructor"));
+ TTabStop tab4;
+ tab4.iTwipsPosition=1440;
+ tab4.iType=TTabStop::ERightTab;
+ TTabStop tab5(tab4);
+ test(tab5.iTwipsPosition==tab4.iTwipsPosition);
+ test(tab5.iType==tab4.iType);
+
+ test.Next(_L("Assignment operator"));
+ tab1=tab5;;
+ test(tab1.iTwipsPosition==tab5.iTwipsPosition);
+ test(tab1.iType==tab5.iType);
+
+ test.Next(_L("Equality operator"));
+ test(tab1==tab5);
+
+ test.Next(_L("Inequality operator"));
+ tab1.iTwipsPosition=2;
+ test(tab1!=tab5);
+ test.End();
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckTParaBorder()
+//
+// Checks TParaBorder construction.
+//
+ {
+ test.Start(_L("Checking all methods"));
+ // Default Constructor.
+ TParaBorder border1;
+
+ test.Next(_L("Default constructor"));
+ test(border1.iLineStyle==TParaBorder::ENullLineStyle);
+ test(border1.iAutoColor);
+ TLogicalRgb c(TLogicalRgb::ESystemForegroundColor);
+ test(border1.iColor == c);
+
+ TParaBorder border2;
+ test.Next(_L("Equality operator"));
+ test(border2==border1);
+
+ test.Next(_L("Inequality operator"));
+ border2.iLineStyle=TParaBorder::ESolid;
+ border2.iThickness=2;
+ test(border2!=border1);
+
+ border1.iLineStyle=TParaBorder::ESolid;
+ border1.iThickness=2;
+ test(border2==border1);
+
+ test.End();
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckTBullet()
+//
+// Checks TBullet construction.
+//
+ {
+ test.Start(_L("Checking all methods"));
+ // Default constructor.
+ TBullet bullet;
+
+ test.Next(_L("Default constructor"));
+ test(0x2022==bullet.iCharacterCode);
+ test(bullet.iHeightInTwips==0);
+
+ test.Next(_L("==/!="));
+ TBullet bullet2;
+ test(bullet==bullet2);
+ test(!(bullet!=bullet2));
+
+ TBullet bullet3;
+ bullet3.iCharacterCode=45;
+ test(bullet!=bullet3);
+ test(!(bullet==bullet3));
+ test.End();
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckCParaFormatTabsEqual(TTabStop& aCheck,TTabStop& aControl)
+//
+// Check the 2 TTabStop structs are equal.
+//
+ {test(aCheck==aControl);}
+
+
+template<class S>
+void TestFormat<S>::CheckCParaFormatL()
+//
+// Checks CParaFormat construction and methods.
+//
+ {
+ test.Start(_L("Checking all methods"));
+ CheckCParaFormatSpecialL();
+ __UHEAP_MARK;
+
+ TInt failRate;
+ CParaFormat* pp=NULL;
+ for (failRate=1;;failRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
+ __UHEAP_MARK;
+ TRAPD(ret,pp=CParaFormat::NewL());
+ if (ret!=KErrNone)
+ {
+ __UHEAP_MARKEND;
+ test(pp==NULL);
+ }
+ else
+ {
+ test(pp!=NULL);
+ delete pp;
+ __UHEAP_MARKEND;
+ break;
+ }
+ }
+ __UHEAP_RESET;
+
+
+
+
+ CParaFormat* format=CParaFormat::NewL();
+
+ test.Next(_L("Tab methods"));
+ TTabStop control[5];
+ control[4].iTwipsPosition=KMaxTUint32;
+ control[3].iTwipsPosition=8640;
+ control[2].iTwipsPosition=5760;
+ control[1].iTwipsPosition=2880;
+ control[0].iTwipsPosition=1;
+
+ control[0].iType=TTabStop::ERightTab;
+ control[1].iType=TTabStop::ECenteredTab;
+
+// Store the tabs.
+ test(format->TabCount()==0);
+ format->StoreTabL(control[4]);
+ test(format->TabCount()==1);
+ format->StoreTabL(control[2]);
+ test(format->TabCount()==2);
+ format->StoreTabL(control[1]);
+ test(format->TabCount()==3);
+ format->StoreTabL(control[3]);
+ test(format->TabCount()==4);
+ format->StoreTabL(control[0]);
+ test(format->TabCount()==5);
+
+// Read the tabs.
+ TTabStop buf;
+ TInt tc1=format->TabCount();
+ for (TInt count=0;count<tc1;count++)
+ {
+ buf=format->TabStop(count);
+ CheckCParaFormatTabsEqual(buf,control[count]);
+ }
+
+// RemoveAllTabs
+ format->RemoveAllTabs();
+ TInt tabCount=format->TabCount();
+ test(tabCount==0);
+
+// Remove the tabs.
+ format->RemoveTab(5760);
+ test(format->TabCount()==0);
+ format->RemoveTab(2880);
+ test(format->TabCount()==0);
+ format->RemoveTab(8640);
+ test(format->TabCount()==0);
+ format->RemoveTab(1);
+ test(format->TabCount()==0);
+ format->RemoveTab(KMaxTUint32);
+ test(format->TabCount()==0);
+
+ delete format;
+ format=NULL;
+ __UHEAP_MARKEND;
+ test.End();
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckCParaFormatSpecialL()
+//
+// Checks CParaFormat construction and methods.
+//
+ {
+ __UHEAP_MARK;
+ CParaFormat* format=CParaFormat::NewLC();
+ CParaFormat* newFormat=CParaFormat::NewLC();
+// Tab functions
+ format->TabCount();
+ TTabStop tab;
+ format->StoreTabL(tab);
+ format->TabStop(0);
+ format->RemoveTab(0);
+ format->RemoveAllTabs();
+// Border functions
+ TParaBorder testBorder;
+ format->RemoveAllBorders();
+ format->BordersPresent();
+ format->AllBordersEqual(*newFormat);
+ format->SetParaBorderL(CParaFormat::EParaBorderTop,testBorder);
+ format->IsBorderEqual(CParaFormat::EParaBorderBottom,*newFormat);
+ CleanupStack::PopAndDestroy(2);
+ format=NULL;
+ __UHEAP_MARKEND;
+ TInt ret;
+ TInt check=0;
+#ifdef _DEBUG
+ __UHEAP_MARK;
+ // Construction.
+ test.Next(_L("Construction failing on OOM"));
+ __UHEAP_FAILNEXT(1);
+ TRAP(ret,format=CParaFormat::NewL());
+ if (ret!=KErrNone)
+ check=1;
+ test(check==1);
+#endif
+ test.Next(_L("Construction succeeding"));
+ check=0;
+ TRAP(ret,format=CParaFormat::NewL());
+ if (ret!=KErrNone)
+ check++;
+ test(check==0);
+ //
+ TLogicalRgb fillColor(TLogicalRgb::ESystemBackgroundColor);
+ test(format->iFillColor==fillColor);
+ test(format->iLanguage==0);
+ test(format->iLeftMarginInTwips==0);
+ test(format->iRightMarginInTwips==0);
+ test(format->iIndentInTwips==0);
+ test(format->iBorderMarginInTwips==0);
+ test(format->iSpaceBeforeInTwips==0);
+ test(format->iSpaceAfterInTwips==0);
+ test(format->iHorizontalAlignment==CParaFormat::ELeftAlign);
+ test(format->iVerticalAlignment==CParaFormat::EUnspecifiedAlign);
+ test(format->iKeepTogether==EFalse);
+ test(format->iKeepWithNext==EFalse);
+ test(format->iStartNewPage==EFalse);
+ test(format->iWidowOrphan==EFalse);
+ test(format->iWrap);
+ test(!format->BordersPresent());
+ test(format->iBullet==NULL);
+ test(format->iLineSpacingInTwips==200);
+ test(format->iLineSpacingControl==CParaFormat::ELineSpacingAtLeastInTwips);
+ test(format->iDefaultTabWidthInTwips==360);
+
+ test.Next(_L("Equality operator"));
+ CParaFormat* two=CParaFormat::NewL();
+ test(two->IsEqual(*format));
+ delete two;
+
+ test.Next(_L("Copy constructor"));
+ CParaFormat* three=CParaFormat::NewL(*two);
+ test(three->IsEqual(*two));
+ delete three;
+
+
+ // Destroy()
+ test.Next(_L("Destroy()"));
+ delete format;
+ format=NULL;
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckTParaFormatMask()
+//
+// Checks TParaFormatMask construction and methods.
+//
+ {
+ __UHEAP_MARK;
+ TInt count=0;
+// All methods.
+ test.Start(_L("Checking all methods"));
+ TParaFormatMask mask;
+ mask.SetAttrib(EAttLeftMargin);
+ mask.AttribIsSet(EAttLeftMargin);
+ mask.ClearAttrib(EAttLeftMargin);
+ TParaFormatMask maskTemp;
+ test(maskTemp==mask);
+ test(!(maskTemp!=mask));
+
+// Construction.
+ test.Next(_L("Construction"));
+ TParaFormatMask mask1;
+ for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+
+
+// SetAttrib()
+ test.Next(_L("SetAttrib()"));
+ for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ mask1.SetAttrib((TTextFormatAttribute)count);
+ }
+
+// ClearAttrib()
+ test.Next(_L("ClearAttrib()"));
+ for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ mask1.ClearAttrib((TTextFormatAttribute)count);
+ }
+ for (count=EAttParaLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+// AttribIsSet()
+ test.Next(_L("AttribIsSet()"));
+ // Already tested in the above.
+
+ test.Next(_L("SetAll()"));
+ TParaFormatMask mask2;
+ mask2.SetAll(); // sets border container but not individual borders.
+ for (count=EAttParaLanguage;count<EAttTabStop;count++)
+ {
+ test(mask2.AttribIsSet((TTextFormatAttribute)count));
+ }
+
+ test.Next(_L("ClearAll()"));
+ mask2.ClearAll();
+ for (count=EAttParaLanguage;count<EAttTabStop;count++)
+ {
+ test(mask2.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+ mask2.SetAttrib(EAttLeftMargin);
+ test(mask2.AttribIsSet(EAttLeftMargin));
+
+ test.End();
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckFormatsEqual(TCharFormat& aControl,TCharFormatMask& aControlMask,TCharFormat& aCheck,TCharFormatMask& aMask)
+//
+// Checks that 2 TCharFormats are exactly equal.
+//
+ {
+ test(aControlMask==aMask);
+ test(aControl.IsEqual(aCheck,aMask));
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckFormatsEqual(CParaFormat* aControl,CParaFormat* aCheck)
+//
+// Checks 2 CParaFormats are exactly equal.
+//
+ {test(aControl->IsEqual(*aCheck));}
+
+
+template<class S>
+void TestFormat<S>::CheckFormatsEqual(TParaFormatMask& aControl,TParaFormatMask& aCheck)
+//
+// Checks the guards are exactly the same.
+//
+ {test(aControl==aCheck);}
+
+
+template<class S>
+void TestFormat<S>::CheckCCharFormatLayerL()
+//
+// Checks CCharFormatLayer constructor and methods.
+//
+ {
+ __UHEAP_MARK;
+
+ TParaFormatMask mmm;
+ CParaFormatLayer* pL=CParaFormatLayer::NewL();
+ CParaFormatLayer* pL1=CParaFormatLayer::NewL(NULL,mmm);
+ mmm.SetAttrib(EAttLeftMargin);
+ CParaFormat ppp;
+ ppp.iLeftMarginInTwips=1000;
+ CParaFormatLayer* pL2=CParaFormatLayer::NewL(&ppp,mmm);
+
+ test(pL->IsEmpty());
+ test(pL1->IsEmpty());
+ test(!(pL2->IsEmpty()));
+
+ delete pL2;
+ delete pL1;
+ delete pL;
+
+ TCharFormat format1,format2,format3,formatCmp;
+ TCharFormatMask f1,f2,f3,fCmp;
+
+ TRgb Color1(10,10,10);
+ TRgb Color2(50,50,50);
+ TRgb hlColor1(3,4,5);
+
+ // Setup layer 1 values
+ format1.iFontPresentation.iTextColor=Color1; f1.SetAttrib(EAttColor);
+ format1.iFontSpec.iHeight=1400; f1.SetAttrib(EAttFontHeight);
+ format1.iFontSpec.iFontStyle.SetPosture(EPostureItalic); f1.SetAttrib(EAttFontPosture);
+ format1.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript); f1.SetAttrib(EAttFontPrintPos);
+ // Setup layer 2 values
+ format2.iFontPresentation.iHighlightColor=hlColor1; f2.SetAttrib(EAttFontHighlightColor);
+ format2.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightRounded; f2.SetAttrib(EAttFontHighlightStyle);
+ format2.iFontPresentation.iStrikethrough=EStrikethroughOn; f2.SetAttrib(EAttFontStrikethrough);
+ format2.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); f2.SetAttrib(EAttFontStrokeWeight);
+ format2.iFontPresentation.iUnderline=EUnderlineOn; f2.SetAttrib(EAttFontUnderline);
+ format2.iFontSpec.iTypeface.iName=(_L("Moffat"));
+ format2.iFontSpec.iTypeface.SetIsProportional(ETrue);
+ format2.iFontSpec.iTypeface.SetIsSerif(ETrue);
+ format2.iFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
+ f2.SetAttrib(EAttFontTypeface);
+ // Setup layer 3 values - should be ignored cos they're already present.
+ format3.iFontPresentation.iTextColor=Color2; f3.SetAttrib(EAttColor);
+ format3.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightNormal; f3.SetAttrib(EAttFontHighlightStyle);
+ format3.iFontSpec.iHeight=2800; f3.SetAttrib(EAttFontHeight);
+ format3.iFontSpec.iFontStyle.SetPosture(EPostureUpright); f3.SetAttrib(EAttFontPosture);
+ format3.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSuperscript); f3.SetAttrib(EAttFontPrintPos);
+ format3.iFontPresentation.iStrikethrough=EStrikethroughOff; f3.SetAttrib(EAttFontStrikethrough);
+ format3.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal); f3.SetAttrib(EAttFontStrokeWeight);
+ format3.iFontPresentation.iUnderline=EUnderlineOff; f3.SetAttrib(EAttFontUnderline);
+ format3.iFontSpec.iTypeface.iName=(_L("Moon"));
+ format3.iFontSpec.iTypeface.SetIsProportional(EFalse);
+ format3.iFontSpec.iTypeface.SetIsSerif(EFalse);
+ f3.SetAttrib(EAttFontTypeface);
+ // Setup formatCmp values - the expected result of format layering.
+ formatCmp.iFontPresentation.iTextColor=Color1; fCmp.SetAttrib(EAttColor);
+ formatCmp.iFontPresentation.iHighlightColor=hlColor1; fCmp.SetAttrib(EAttFontHighlightColor);
+ formatCmp.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightRounded; fCmp.SetAttrib(EAttFontHighlightStyle);
+ formatCmp.iFontSpec.iHeight=1400; fCmp.SetAttrib(EAttFontHeight);
+ formatCmp.iFontSpec.iFontStyle.SetPosture(EPostureItalic); fCmp.SetAttrib(EAttFontPosture);
+ formatCmp.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript); fCmp.SetAttrib(EAttFontPrintPos);
+ formatCmp.iFontPresentation.iStrikethrough=EStrikethroughOn; fCmp.SetAttrib(EAttFontStrikethrough);
+ formatCmp.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); fCmp.SetAttrib(EAttFontStrokeWeight);
+ formatCmp.iFontPresentation.iUnderline=EUnderlineOn; fCmp.SetAttrib(EAttFontUnderline);
+ formatCmp.iFontSpec.iTypeface.iName=(_L("Moffat"));
+ formatCmp.iFontSpec.iTypeface.SetIsProportional(ETrue);
+ formatCmp.iFontSpec.iTypeface.SetIsSerif(ETrue);
+ formatCmp.iFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
+ fCmp.SetAttrib(EAttFontTypeface);
+ // Store the formats in char format layers
+ CCharFormatLayer* formatLayer3=CCharFormatLayer::NewL(format3,f3);
+ CCharFormatLayer* formatLayer2=CCharFormatLayer::NewL(format2,f2);
+ CCharFormatLayer* formatLayer1=CCharFormatLayer::NewL(format1,f1);
+ formatLayer1->SetBase(formatLayer2);
+ test.Start(_L("ChainCount()"));
+ test(formatLayer1->ChainCount()==2);
+ // Now read them in and compare them:
+ // First just the layers.
+ test.Next(_L("SenseL() - Sensing this layer only"));
+ TCharFormat result1;
+ TCharFormatMask result1Mask;
+ formatLayer1->Sense(result1,result1Mask);
+ CheckFormatsEqual(format1,f1,result1,result1Mask);
+
+ TCharFormat result2;
+ TCharFormatMask result2Mask;
+ formatLayer2->Sense(result2,result2Mask);
+ CheckFormatsEqual(format2,f2,result2,result2Mask);
+ test(result2.iFontSpec.iFontStyle.BitmapType() == format2.iFontSpec.iFontStyle.BitmapType());
+ test(result2.iFontSpec.iFontStyle.BitmapType() == EAntiAliasedGlyphBitmap);
+
+ // Now check the effective formats are correct
+ test.Next(_L("SenseEffectiveL() - utilising basedOn"));
+ TCharFormatMask dummy;
+ TCharFormat result3;
+ formatLayer1->SenseEffective(result3);
+ CheckFormatsEqual(format3,dummy,result3,dummy);
+
+ // Now check the effective formats are correct
+ // The result should be the same as above,
+ // since all these values are present in the resultant TCharFormat.
+ // Ie, checking that overlapping attributes in a lower layer are not taken.
+ test.Next(_L("SenseEffectiveL() - checking overlapping attributes are ignored"));
+ // Add another layer of formatting by implementing the next based on link.
+ formatLayer2->SetBase(formatLayer3);
+ test.Next(_L("ChainCount()"));
+ test(formatLayer1->ChainCount()==3);
+ test(formatLayer2->ChainCount()==2);
+ test(formatLayer3->ChainCount()==1);
+ TCharFormat result4;
+ formatLayer1->SenseEffective(result4);
+ CheckFormatsEqual(format3,dummy,result4,dummy);
+
+ test.End();
+ delete formatLayer1;
+ delete formatLayer2;
+ delete formatLayer3;
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckCParaFormatLayerRestL()
+//
+// Checks combinations of set and sense with format layering.
+//
+ {
+ __UHEAP_MARK;
+ CParaFormat* format1=CParaFormat::NewL();
+ TParaFormatMask format1Mask;
+
+ CParaFormat* format2=CParaFormat::NewL();
+ TParaFormatMask format2Mask;
+
+ CParaFormat* format3=CParaFormat::NewL();
+
+ CParaFormat* format4=CParaFormat::NewL();
+ TParaFormatMask format4Mask;
+
+ TRgb Color1(10,10,10);
+ TRgb Color2(50,50,50);
+ TRgb Color3(100,100,100);
+ TRgb Color4(150,150,150);
+
+ TTabStop tab1layer1,tab2layer1,tab3layer1;
+ tab1layer1.iTwipsPosition=2520; tab1layer1.iType=TTabStop::ECenteredTab;
+ tab2layer1.iTwipsPosition=3960; tab2layer1.iType=TTabStop::ERightTab;
+ tab3layer1.iTwipsPosition=11160;tab3layer1.iType=TTabStop::ELeftTab;
+ TTabStop tab1layer2,tab2layer2,tab3layer2;
+ tab1layer2.iTwipsPosition=2160; tab1layer2.iType=TTabStop::ENullTab;
+ tab2layer2.iTwipsPosition=3600; tab2layer2.iType=TTabStop::ENullTab;
+ tab3layer2.iTwipsPosition=10080;tab3layer2.iType=TTabStop::ENullTab;
+ TTabStop tab1layer3,tab2layer3,tab3layer3;
+ tab1layer3.iTwipsPosition=2160; tab1layer3.iType=TTabStop::ECenteredTab;
+ tab2layer3.iTwipsPosition=3600; tab2layer3.iType=TTabStop::ERightTab;
+ tab3layer3.iTwipsPosition=10080;tab3layer3.iType=TTabStop::ELeftTab;
+ // Setup layer 1 values.
+ format1->iFillColor=Color1; format1Mask.SetAttrib(EAttFillColor);
+ format1->iLeftMarginInTwips=1440; format1Mask.SetAttrib(EAttLeftMargin);
+ format1->iRightMarginInTwips=7000; format1Mask.SetAttrib(EAttRightMargin);
+ format1->iIndentInTwips=1500; format1Mask.SetAttrib(EAttIndent);
+ format1->iHorizontalAlignment=CParaFormat::ERightAlign; format1Mask.SetAttrib(EAttAlignment);
+ format1->iVerticalAlignment=CParaFormat::EBottomAlign; format1Mask.SetAttrib(EAttVerticalAlignment);
+ format1->iLineSpacingInTwips=12; format1Mask.SetAttrib(EAttLineSpacing);
+ format1->iSpaceBeforeInTwips=6; format1Mask.SetAttrib(EAttSpaceBefore);
+ format1->iSpaceAfterInTwips=7; format1Mask.SetAttrib(EAttSpaceAfter);
+ format1->iKeepTogether=ETrue; format1Mask.SetAttrib(EAttKeepTogether);
+ format1->iKeepWithNext=ETrue; format1Mask.SetAttrib(EAttKeepWithNext);
+ format1->iStartNewPage=ETrue; format1Mask.SetAttrib(EAttStartNewPage);
+ format1->iWidowOrphan=ETrue; format1Mask.SetAttrib(EAttWidowOrphan);
+ format1->iWrap=EFalse; format1Mask.SetAttrib(EAttWrap);
+ format1->iDefaultTabWidthInTwips=2880; format1Mask.SetAttrib(EAttDefaultTabWidth);
+ format1->StoreTabL(tab1layer1); format1->StoreTabL(tab2layer1); format1->StoreTabL(tab3layer1);
+ format1Mask.SetAttrib(EAttTabStop);
+ // Setup format 2 values.
+ TParaBorder topBorder;
+ topBorder.iLineStyle=TParaBorder::ESolid;
+ topBorder.iThickness=1;
+ topBorder.iAutoColor=ETrue;
+ topBorder.iColor=Color1;
+ format2->SetParaBorderL(CParaFormat::EParaBorderTop,topBorder);
+ format2Mask.SetAttrib(EAttTopBorder);
+ //
+ TParaBorder bottomBorder;
+ bottomBorder.iLineStyle=TParaBorder::ESolid;
+ bottomBorder.iThickness=1;
+ bottomBorder.iAutoColor=ETrue;
+ bottomBorder.iColor=Color2;
+ format2->SetParaBorderL(CParaFormat::EParaBorderBottom,bottomBorder);
+ format2Mask.SetAttrib(EAttBottomBorder);
+ //
+ TParaBorder leftBorder;
+ leftBorder.iLineStyle=TParaBorder::ESolid;
+ leftBorder.iThickness=1;
+ leftBorder.iAutoColor=ETrue;
+ leftBorder.iColor=Color3;
+ format2->SetParaBorderL(CParaFormat::EParaBorderLeft,leftBorder);
+ format2Mask.SetAttrib(EAttLeftBorder);
+ //
+ TParaBorder rightBorder;
+ rightBorder.iLineStyle=TParaBorder::ESolid;
+ rightBorder.iThickness=1;
+ rightBorder.iAutoColor=ETrue;
+ rightBorder.iColor=Color4;
+ format2->SetParaBorderL(CParaFormat::EParaBorderRight,rightBorder);
+ format2Mask.SetAttrib(EAttRightBorder);
+ //
+ format2->StoreTabL(tab1layer2); format2->StoreTabL(tab2layer2); format2->StoreTabL(tab3layer2);
+ format2Mask.SetAttrib(EAttTabStop);
+ format2->iBullet=new(ELeave)TBullet; format2Mask.SetAttrib(EAttBullet);
+ format2->iBullet->iHeightInTwips=200;
+ format2->iBullet->iCharacterCode=202;
+ format2->iBullet->iTypeface.iName=(_L("Symbol"));
+ format2->iBullet->iTypeface.SetIsProportional(ETrue);
+ format2->iBullet->iTypeface.SetIsSerif(ETrue);
+ // Setup format 3 values - The resulting format after hunting based on links.
+ format3->iFillColor=Color1;
+ format3->iLeftMarginInTwips=1440;
+ format3->iRightMarginInTwips=7000;
+ format3->iIndentInTwips=1500;
+ format3->iHorizontalAlignment=CParaFormat::ERightAlign;
+ format3->iVerticalAlignment=CParaFormat::EBottomAlign;
+ format3->iLineSpacingInTwips=12;
+ format3->iSpaceBeforeInTwips=6;
+ format3->iSpaceAfterInTwips=7;
+ format3->iKeepTogether=ETrue;
+ format3->iKeepWithNext=ETrue;
+ format3->iStartNewPage=ETrue;
+ format3->iWidowOrphan=ETrue;
+ format3->iWrap=EFalse;
+ format3->iDefaultTabWidthInTwips=2880;
+ TParaBorder top;
+ top.iLineStyle=TParaBorder::ESolid;
+ top.iThickness=1;
+ top.iAutoColor=ETrue;
+ top.iColor=Color1;
+ TParaBorder bottom;
+ bottom.iLineStyle=TParaBorder::ESolid;
+ bottom.iThickness=1;
+ bottom.iAutoColor=ETrue;
+ bottom.iColor=Color2;
+ TParaBorder left;
+ left.iLineStyle=TParaBorder::ESolid;
+ left.iThickness=1;
+ left.iAutoColor=ETrue;
+ left.iColor=Color3;
+ TParaBorder right;
+ right.iThickness=1;
+ right.iLineStyle=TParaBorder::ESolid;
+ right.iAutoColor=ETrue;
+ right.iColor=Color4;
+ format3->SetParaBorderL(CParaFormat::EParaBorderTop,top);
+ format3->SetParaBorderL(CParaFormat::EParaBorderBottom,bottom);
+ format3->SetParaBorderL(CParaFormat::EParaBorderLeft,left);
+ format3->SetParaBorderL(CParaFormat::EParaBorderRight,right);
+ //
+ format3->StoreTabL(tab1layer1); format3->StoreTabL(tab2layer1); format3->StoreTabL(tab3layer1);
+// format3->StoreTabL(tab1layer2); format3->StoreTabL(tab2layer2); format3->StoreTabL(tab3layer2);
+ format3->iBullet=new(ELeave)TBullet;
+ format3->iBullet->iHeightInTwips=200;
+ format3->iBullet->iCharacterCode=202;
+ format3->iBullet->iTypeface.iName=(_L("Symbol"));
+ format3->iBullet->iTypeface.SetIsProportional(ETrue);
+ format3->iBullet->iTypeface.SetIsSerif(ETrue);
+ // Setup format 4 values - The resulting format after hunting based on links.
+ // and ignoring all these attributes since they are already set in the CParaFormat.
+ format4->iLeftMarginInTwips=6666; format4Mask.SetAttrib(EAttLeftMargin);
+ format4->iRightMarginInTwips=6666; format4Mask.SetAttrib(EAttRightMargin);
+ format4->iIndentInTwips=6666; format4Mask.SetAttrib(EAttIndent);
+ format4->iHorizontalAlignment=CParaFormat::ERightAlign; format4Mask.SetAttrib(EAttAlignment);
+ format4->iLineSpacingInTwips=6666; format4Mask.SetAttrib(EAttLineSpacing);
+ format4->iSpaceBeforeInTwips=6666; format4Mask.SetAttrib(EAttSpaceBefore);
+ format4->iSpaceAfterInTwips=6666; format4Mask.SetAttrib(EAttSpaceAfter);
+ format4->iKeepTogether=EFalse; format4Mask.SetAttrib(EAttKeepTogether);
+ format4->iKeepWithNext=EFalse; format4Mask.SetAttrib(EAttKeepWithNext);
+ format4->iStartNewPage=EFalse; format4Mask.SetAttrib(EAttStartNewPage);
+ format4->iWidowOrphan=EFalse; format4Mask.SetAttrib(EAttWidowOrphan);
+ format4->iDefaultTabWidthInTwips=6666; format4Mask.SetAttrib(EAttDefaultTabWidth);
+ TParaBorder zTop;
+ zTop.iLineStyle=TParaBorder::EDashed;
+ format4Mask.SetAttrib(EAttTopBorder);
+ zTop.iAutoColor=EFalse;
+ TParaBorder zBottom;
+ zBottom.iLineStyle=TParaBorder::EDashed;
+ format4Mask.SetAttrib(EAttBottomBorder);
+ zBottom.iAutoColor=EFalse;
+ TParaBorder zLeft;
+ zLeft.iLineStyle=TParaBorder::EDashed;
+ format4Mask.SetAttrib(EAttLeftBorder);
+ zLeft.iAutoColor=EFalse;
+ TParaBorder zRight;
+ zRight.iLineStyle=TParaBorder::EDashed;
+ format4Mask.SetAttrib(EAttRightBorder);
+ zRight.iAutoColor=EFalse;
+ format4->SetParaBorderL(CParaFormat::EParaBorderTop,zTop);
+ format4->SetParaBorderL(CParaFormat::EParaBorderBottom,zBottom);
+ format4->SetParaBorderL(CParaFormat::EParaBorderLeft,zLeft);
+ format4->SetParaBorderL(CParaFormat::EParaBorderRight,zRight);
+ //
+ format4->StoreTabL(tab1layer3); format4->StoreTabL(tab2layer3); format4->StoreTabL(tab3layer3);
+ format4Mask.SetAttrib(EAttTabStop);
+ format4->iBullet=new(ELeave)TBullet; format4Mask.SetAttrib(EAttBullet);
+ format4->iBullet->iHeightInTwips=240;
+ format4->iBullet->iCharacterCode=201;
+ format4->iBullet->iTypeface.iName=(_L("Windings"));
+ format4->iBullet->iTypeface.SetIsSerif(ETrue);
+ format4->iBullet->iTypeface.SetIsProportional(EFalse);
+ // Store the formats in para format layers
+ CParaFormatLayer* formatLayer4=CParaFormatLayer::NewL(format4,format4Mask);
+
+ CParaFormatLayer* formatLayer2=CParaFormatLayer::NewL(format2,format2Mask);
+
+ CParaFormatLayer* formatLayer=CParaFormatLayer::NewL(format1,format1Mask);
+ formatLayer->SetBase(formatLayer2);
+
+ // Now read them in and compare them:
+ // First just the layers.
+ test.Next(_L("SenseL() - Sensing this layer only"));
+ CParaFormat* formatResult1=CParaFormat::NewL();
+ TParaFormatMask formatResult1Mask;
+ formatLayer->SenseL(formatResult1,formatResult1Mask);
+ CheckFormatsEqual(format1,formatResult1);
+ CheckFormatsEqual(format1Mask,formatResult1Mask);
+ delete formatResult1;
+
+ formatResult1=CParaFormat::NewL();
+ formatResult1Mask.ClearAll();
+ formatLayer2->SenseL(formatResult1,formatResult1Mask);
+ CheckFormatsEqual(format2,formatResult1);
+ CheckFormatsEqual(format2Mask,formatResult1Mask);
+ delete formatResult1;
+
+ // Now check the effective formats are correct
+ test.Next(_L("SenseEffectiveL() - utilising basedOn"));
+ CParaFormat* formatResult2=CParaFormat::NewL();
+ formatLayer->SenseEffectiveL(formatResult2);
+ CheckFormatsEqual(format3,formatResult2);
+ delete formatResult2;
+
+ // Now check the effective formats are correct
+ // The result should be the same as above,
+ // since all these values are present in the resultant CParaFormat.
+ // Ie, checking that overlapping attributes in a lower layer are not taken.
+ test.Next(_L("SenseEffectiveL() - checking overlapping attributes are ignored"));
+ // Add another layer of formatting by implementing the next based on link.
+ formatLayer2->SetBase(formatLayer4);
+ formatResult2=CParaFormat::NewL();
+ formatLayer->SenseEffectiveL(formatResult2);
+ CheckFormatsEqual(format3,formatResult2);
+ delete formatResult2;
+
+ // Test ChainCount() method
+ test.Next(_L("ChainCount()"));
+ test(formatLayer4->ChainCount()==1);
+ test(formatLayer2->ChainCount()==2);
+ test(formatLayer->ChainCount()==3);
+
+ // Now clean up.
+ delete formatLayer;
+ delete formatLayer2;
+ delete formatLayer4;
+ //formatLayer3 does not exist, so each can use it's own same numbered format.
+ delete format1;
+ delete format2;
+ delete format3;
+ delete format4;
+ __UHEAP_MARKEND;
+ }
+
+
+LOCAL_C void CheckBulletInheritance()
+//
+// Checks correct inheritance of bullets.
+//
+ {
+ test.Next(_L("Testing bullet inheritance"));
+ __UHEAP_MARK;
+
+ CParaFormatLayer* baseLayer=CParaFormatLayer::NewL();
+ CParaFormatLayer* specificLayer=CParaFormatLayer::NewL();
+ specificLayer->SetBase(baseLayer);
+ CParaFormat* paraFormat=CParaFormat::NewLC();
+ paraFormat->iBullet=new(ELeave) TBullet;
+ paraFormat->iBullet->iHeightInTwips=200;
+ paraFormat->iBullet->iCharacterCode=202;
+ TParaFormatMask paraMask;
+ paraMask.SetAttrib(EAttBullet);
+ specificLayer->SetL(paraFormat,paraMask);
+ //
+ // specific bullet over null inherited
+ test.Start(_L("Specific bullet over null inherited"));
+ CParaFormat* sensed=CParaFormat::NewLC();
+ specificLayer->SenseEffectiveL(sensed);
+ test(sensed->iBullet!=NULL);
+ test(sensed->iBullet->iHeightInTwips==200);
+ CleanupStack::PopAndDestroy(); // sensed
+ //
+ // null bullet over inherited
+ test.Next(_L("Null bullet over inherited"));
+ baseLayer->Reset();
+ specificLayer->Reset();
+ baseLayer->SetL(paraFormat,paraMask);
+ CParaFormat* empty=CParaFormat::NewLC();
+ TParaFormatMask temp;
+ temp.SetAttrib(EAttBullet);
+ specificLayer->SetL(empty,temp);
+ CleanupStack::PopAndDestroy(); // empty
+ sensed=CParaFormat::NewLC();
+ specificLayer->SenseEffectiveL(sensed);
+ CleanupStack::PopAndDestroy(); // sensed
+// test(sensed->iBullet==NULL);
+ //
+ // non-null bullet over inherited bullet
+ test.Next(_L("Non-Null bullet over inherited"));
+ specificLayer->Reset();
+ paraFormat->iBullet->iHeightInTwips=1000;
+ specificLayer->SetL(paraFormat,paraMask);
+ sensed=CParaFormat::NewLC();
+ specificLayer->SenseEffectiveL(sensed);
+ test(sensed->iBullet!=NULL);
+ test(sensed->iBullet->iHeightInTwips==1000);
+ CleanupStack::PopAndDestroy(); // sensed
+
+ CleanupStack::PopAndDestroy(); // paraFormat.
+ delete specificLayer;
+ delete baseLayer;
+ test.End();
+
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckCParaFormatLayerL()
+//
+// Checks CParaFormatLayer construction and methods.
+//
+ {
+ __UHEAP_MARK;
+
+
+ TInt ret=0;
+ TInt check=0;
+ CParaFormatLayer* layer0=NULL;
+
+ test.Start(_L("Constructor"));
+#ifdef _DEBUG
+ test.Next(_L("Failing on OOM"));
+ __UHEAP_FAILNEXT(1);
+ TRAP(ret,layer0=CParaFormatLayer::NewL());
+ if (ret!=KErrNone)
+ check++;
+ test(check>0);
+#endif
+
+ test.Next(_L("Succeeding"));
+ check=0;
+ TRAP(ret,layer0=CParaFormatLayer::NewL());
+ if (ret!=KErrNone)
+ check++;
+ test(check==0);
+ delete layer0;
+
+// Set/Sense Default Para Format.
+ test.Next(_L("Set/Sense Default ParaFormat"));
+ CParaFormat* defaultFormat=CParaFormat::NewL();
+
+ //to test EAttParaLanguageX
+ defaultFormat->iLanguage |= 0x100;
+
+ //set iBullet as a valid bullet to test EAttBullet and EAttBulletX
+ defaultFormat->iBullet=new(ELeave)TBullet;
+ defaultFormat->iBullet->iStyle = TBullet::EBulletStyle;
+ defaultFormat->iBullet->iHeightInTwips = 1;
+
+ TParaFormatMask defaultGuard;
+ defaultGuard.SetAttrib(EAttParaLanguage);
+ defaultGuard.SetAttrib(EAttBullet);
+ defaultGuard.SetAttrib(EAttLeftMargin);
+ defaultGuard.SetAttrib(EAttRightMargin);
+ defaultGuard.SetAttrib(EAttIndent);
+ defaultGuard.SetAttrib(EAttAlignment);
+ defaultGuard.SetAttrib(EAttLineSpacing);
+ defaultGuard.SetAttrib(EAttLineSpacingControl);
+ defaultGuard.SetAttrib(EAttSpaceBefore);
+ defaultGuard.SetAttrib(EAttSpaceAfter);
+ defaultGuard.SetAttrib(EAttKeepTogether);
+ defaultGuard.SetAttrib(EAttKeepWithNext);
+ defaultGuard.SetAttrib(EAttStartNewPage);
+ defaultGuard.SetAttrib(EAttWidowOrphan);
+ defaultGuard.SetAttrib(EAttBorderMargin);
+ defaultGuard.SetAttrib(EAttDefaultTabWidth);
+
+ CParaFormat* buffer1=CParaFormat::NewL();
+ TParaFormatMask bufferGuard1;
+ CParaFormat* buffer2=CParaFormat::NewL();
+
+ CParaFormatLayer* testing1=CParaFormatLayer::NewL();
+ testing1->SetL(defaultFormat,defaultGuard);
+ testing1->SenseL(buffer1,bufferGuard1);
+ testing1->SenseEffectiveL(buffer2);
+
+ test(defaultFormat->IsEqual(*buffer1));
+ test(defaultFormat->IsEqual(*buffer2));
+ CheckFormatsEqual(defaultGuard,bufferGuard1);
+
+ delete testing1;
+
+ delete defaultFormat;
+ delete buffer1;
+ delete buffer2;
+
+ CheckCParaFormatLayerRestL();
+ __UHEAP_MARKEND;
+ test.End();
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckTCharFormat()
+//
+// Checks the TCharFormat construction.
+//
+ {
+ __UHEAP_MARK;
+// All methods
+ test.Start(_L("Constructor"));
+ TCharFormat format;
+ test(format.iLanguage==0);
+
+ test.Next(_L("Constructor with arguments"));
+ TInt height=240;
+ TBuf<32> name=_S("arial");
+ TCharFormat format1(name,height);
+ format1.iFontSpec.iTypeface.SetAttributes(TTypeface::EProportional|TTypeface::ESerif);
+ TCharFormat control;
+ control.iFontSpec.iHeight=240;
+ control.iFontSpec.iTypeface.iName=_S("arial");
+ test(format1.IsEqual(control));
+
+ test.End();
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckTCharFormatMask()
+//
+// Checks TCharFormatMask construction and methods.
+//
+ {
+ __UHEAP_MARK;
+// All methods.
+ TInt count=0;
+ test.Start(_L("Checking all methods"));
+ TCharFormatMask mask;
+ mask.SetAttrib(EAttFontHeight);
+ mask.AttribIsSet(EAttFontHeight);
+ mask.ClearAttrib(EAttFontHeight);
+// Construction.
+ test.Next(_L("Construction"));
+ TCharFormatMask mask1;
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+// SetAttrib()
+ test.Next(_L("SetAttrib()"));
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ mask1.SetAttrib((TTextFormatAttribute)count);
+ }
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask1.AttribIsSet((TTextFormatAttribute)count));
+ }
+// ClearAttrib()
+ test.Next(_L("ClearAttrib()"));
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ mask1.ClearAttrib((TTextFormatAttribute)count);
+ }
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask1.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+// AttribIsSet()
+ test.Next(_L("AttribIsSet()"));
+ // Already tested in the above.
+ test.Next(_L("SetAll()"));
+ TCharFormatMask mask2;
+ mask2.SetAll();
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask2.AttribIsSet((TTextFormatAttribute)count));
+ }
+ test.Next(_L("ClearAll()"));
+ mask2.ClearAll();
+ for (count=EAttCharLanguage;count<ETextFormatAttributeCount;count++)
+ {
+ test(mask2.AttribIsSet((TTextFormatAttribute)count)==EFalse);
+ }
+ test.End();
+ __UHEAP_MARKEND;
+ }
+
+
+template<class S>
+void TestFormat<S>::CheckAllClassesL()
+//
+// Check all classes and structs exist.
+//
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-ETEXT-LEGACY-T_FMT-0001 TTabStop "));
+ CheckTTabStop();
+
+ test.Next(_L("TParaBorder"));
+ CheckTParaBorder();
+
+ test.Next(_L("TBullet"));
+ CheckTBullet();
+
+ test.Next(_L("CParaFormat"));
+ CheckCParaFormatL();
+
+ test.Next(_L("TParaFormatMask"));
+ CheckTParaFormatMask();
+
+ test.Next(_L("CParaFormatLayer"));
+ CheckCParaFormatLayerL();
+
+ test.Next(_L("TCharFormat"));
+ CheckTCharFormat();
+
+ test.Next(_L("TCharFormatMask"));
+ CheckTCharFormatMask();
+
+ test.Next(_L("CCharFormatLayer"));
+ CheckCCharFormatLayerL();
+
+ }
+
+
+LOCAL_C void TestSettingNullTabsL()
+// Tests setting null tabs into a para format with tab stops.
+//
+ {
+ test.Start(_L("Setting Null Tabs"));
+
+ CCharFormatLayer* charLayer=CCharFormatLayer::NewL();
+ CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();
+ //
+ CRichText* text=CRichText::NewL(paraLayer,charLayer);
+ //
+ // Set tabs in the first paragraph.
+ CParaFormat* paraFormat=CParaFormat::NewLC();
+ TTabStop tabA;
+ tabA.iTwipsPosition=100;
+ tabA.iType=TTabStop::ELeftTab;
+ TTabStop tabB;
+ tabB.iTwipsPosition=200;
+ tabB.iType=TTabStop::ELeftTab;
+ TTabStop tabC;
+ tabC.iTwipsPosition=300;
+ tabC.iType=TTabStop::ERightTab;
+ paraFormat->StoreTabL(tabA);
+ paraFormat->StoreTabL(tabB);
+ paraFormat->StoreTabL(tabC);
+ TParaFormatMask paraMask;
+ paraMask.SetAttrib(EAttTabStop);
+ text->ApplyParaFormatL(paraFormat,paraMask,0,0);
+ CleanupStack::PopAndDestroy(); // paraFormat
+ //
+ // Test that the tabs have been stored.
+ CParaFormat* result=CParaFormat::NewLC();
+ TParaFormatMask resultMask;
+ text->GetParagraphFormatL(result,0);
+ test(result->TabCount()==3);
+ //
+ // Now set zero tabs
+ text->InsertL(0,CEditableText::EParagraphDelimiter);
+ CParaFormat* newFormat=CParaFormat::NewLC();
+ TParaFormatMask newMask;
+ newMask.SetAttrib(EAttTabStop);
+ text->ApplyParaFormatL(newFormat,newMask,1,0);
+ CleanupStack::PopAndDestroy(); // newFormat
+ //
+ // Test how many tabs we have in the new paragraph
+ CleanupStack::PopAndDestroy(); // result
+ result=CParaFormat::NewLC();
+ resultMask.ClearAll();
+ text->GetParagraphFormatL(result,1);
+ test(result->TabCount()==0);
+ CleanupStack::PopAndDestroy(); // result
+ //
+ // Cleanup
+ delete text;
+ delete paraLayer;
+ delete charLayer;
+ test.End();
+ }
+
+
+LOCAL_C void TestFormatLayerResetL()
+// Test CFormatLayer::Reset();
+//
+ {
+ test.Start(_L("CFormatLayer::Reset()"));
+
+ CCharFormatLayer* charLayer=CCharFormatLayer::NewL();
+ TCharFormat charFormat;
+ TCharFormatMask charFormatMask;
+ charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
+ charFormat.iFontSpec.iFontStyle.SetPosture(EPostureItalic);
+ charFormat.iFontPresentation.iStrikethrough=EStrikethroughOn;
+ charFormat.iFontPresentation.iUnderline=EUnderlineOn;
+ charFormatMask.SetAll();
+ charLayer->SetL(charFormat,charFormatMask);
+ //
+ TCharFormat formatOne;
+ TCharFormatMask formatOneMask;
+ charLayer->Sense(formatOne,formatOneMask);
+ test(formatOne.iFontSpec.iFontStyle.StrokeWeight()==EStrokeWeightBold);
+ //
+ charLayer->Reset();
+ //
+ TCharFormat result;
+ TCharFormatMask resultMask;
+ charLayer->Sense(result,resultMask);
+ //
+ TCharFormat comparator;
+ test(result.IsEqual(comparator));
+ //
+ delete charLayer;
+ test.End();
+ }
+
+
+GLDEF_C TInt E32Main()
+//
+// Tests TFORMAT.
+//
+ {
+ CTrapCleanup* cleanup=CTrapCleanup::New();
+ test.Title();
+ TestFormat<TText>* fmt=new(ELeave) TestFormat<TText>;
+ TRAPD(ret,fmt->CheckAllClassesL());
+
+ TRAP(ret,
+ TestFormatLayerResetL());
+ test(ret==KErrNone);
+
+ TRAP(ret,
+ TestSettingNullTabsL());
+ test(ret==KErrNone);
+
+ TRAP(ret,
+ CheckBulletInheritance());
+ test(ret==KErrNone);
+
+ test.End();
+
+ __UHEAP_MARK;
+ delete(fmt);
+ fmt=NULL;
+ __UHEAP_MARKEND;
+ test.Close();
+
+ delete cleanup;
+
+ return(0);
+ }