/*
* 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);
	}