/*

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