/*

 * Copyright (c) 1997-2010 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 <txtetext.h>

 #include <txtglobl.h>

 #include <txtfmlyr.h>

 #include <s32mem.h>

 #include <s32file.h>

 #include <fldbase.h>

 #include <fldbltin.h>

 #include <flddef.h>

 #include "T_CONVS.h"

 #define test(cond)											\

 	{														\

 	TBool __bb = (cond);									\

 	TEST(__bb);												\

 	if (!__bb)												\

 		{													\

 		ERR_PRINTF1(_L("ERROR: Test Failed"));				\

 		User::Leave(1);										\

 		}													\

 	}

 const TInt KTestCleanupStack=0x20;

 const TInt KTestExpandSize=0x20;

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D	TPtrC bigBuf(_L("This is a very big buffer indeed, containing text and special characters,\

  big enough to fill a segment of an editable text component that employs segmented storage"));

 ////////////////////////////////////////////////////////////////////////////////////////////

 class TTestFieldFactoryCONVS : public MTextFieldFactory

 	{

 public:

 	// from MTextFieldFactory

 	virtual CTextField* NewFieldL(TUid aFieldType); 

 	// Creates a field of the type specified

 	// Returns NULL if it does not recognise/support the field type

 	};

 CTextField* TTestFieldFactoryCONVS::NewFieldL(TUid aFieldType)

 // Creates a field (in aHeader) of the type specified in aHeader

 // 

 	{

 	CTextField* field=NULL;

 	if (aFieldType==KDateTimeFieldUid)

 		field = (CTextField*)new(ELeave) CDateTimeField();

 	return field;

 	}

 /////////////////////////////////////////////////////////////////////////////////////////////

 template <class T>

 void CT_CONVS::testCopy(T &aCopy,const T &anOriginal)

 //

 // Copy anOriginal to aCopy using memory-based streams.

 //

 	{

 	CBufSeg *buf=CBufSeg::NewL(KTestExpandSize);

 	if (buf==NULL)

 		User::Panic(_L("Allocating buffer"), 1234);

 //	Write anOriginal out to the buffer.

 	RBufWriteStream out(*buf);

 	TRAPD(r,out<<anOriginal);

 	test(r==KErrNone);

 	TRAP(r,out.CommitL());

 	if (r!=KErrNone)

 	    User::Panic(_L("Committing write stream"), 1234);

 //	Read anOriginal in from the buffer.

 	RBufReadStream in(*buf);

 	TRAP(r,in>>aCopy);

 	test(r==KErrNone);

 //	See if it's consumed the lot.

 	TRAP(r,in.ReadUint8L());

 	test(r==KErrEof);

 //

 	delete buf;

 	}

 _LIT(KOutputFile, "c:\\etext\\t_convs.tst");

 template <class T>

 void CT_CONVS::testStoreRestoreL(T& aCopy,const T& aOriginal)

 // Test document persistance.

 //

     {

 	// set up the store

 	RFs	theFs;

 	theFs.Connect();

 	//

 	theFs.Delete(KOutputFile);

 	theFs.MkDirAll(KOutputFile);

 	CFileStore* theStore=CDirectFileStore::CreateL(theFs,KOutputFile,EFileRead|EFileWrite);

 	CleanupStack::PushL(theStore);

 	theStore->SetTypeL(KDirectFileStoreLayoutUid);

 	//

 	// store the original

 	TStreamId id(0);

 	TRAPD(ret,id=aOriginal.StoreL(*theStore));

 		test(ret==KErrNone);

 	//

 	// restore into the copy

 	TRAP(ret,aCopy.RestoreL(*theStore,id));

 		test(ret==KErrNone);

 	//

 	// tidy up

 	CleanupStack::PopAndDestroy();  // theStore

 	theFs.Close();

     }

 template <class T>

 void CT_CONVS::testCopyChain(T &aCopy,const T &anOriginal,TInt aExcludeCount,const CFormatLayer* aBase)

 //

 // Copy anOriginal to aCopy using memory-based streams.

 //

 	{

 	CBufSeg *buf=CBufSeg::NewL(KTestExpandSize);

 	if (buf==NULL)

 	    User::Panic(_L("Allocating buffer"), 1234);

 //	Write anOriginal out to the buffer.

 	RBufWriteStream out(*buf);

 	TRAPD(r,anOriginal.ExternalizeChainL(out,aExcludeCount));

 	test(r==KErrNone);

 	TRAP(r,out.CommitL());

 	if (r!=KErrNone)

 	    User::Panic(_L("Committing write stream"), 1234);

 //	Read anOriginal in from the buffer.

 	RBufReadStream in(*buf);

 	TRAP(r,aCopy.InternalizeChainL(in,aBase));

 	test(r==KErrNone);

 //	See if it's consumed the lot.

 	TRAP(r,in.ReadUint8L());

 	test(r!=KErrNone);

 //

 	delete buf;

 	}

 TInt CT_CONVS::IsEqual(const CPlainText* aCopy,const CPlainText* aOriginal)

 //

 // Returns true if aCopy contents matches aOriginal contents.

 // Takes account of multiple segments of a segmented text component.

 //

 	{

 	TInt lengthOfOriginal=aOriginal->DocumentLength();

 	TInt lengthOfCopy=aCopy->DocumentLength();

 	test(lengthOfOriginal==lengthOfCopy);

 //

 	TPtrC copy,orig;

 //

 	TInt lengthRead=0;

 	while(lengthRead<=lengthOfOriginal)

 		{

 		copy.Set((aCopy->Read(lengthRead)));

 		orig.Set((aOriginal->Read(lengthRead)));

 		for (TInt offset=0; offset<orig.Length(); offset++)

 			test(copy[offset]==orig[offset]);

 		lengthRead+=orig.Length();

 		}

 	test(lengthRead==lengthOfOriginal+1);

 	test(aCopy->FieldCount()==aOriginal->FieldCount());

 	return 1;

 	}

 void CT_CONVS::testPlainTextL(CEditableText::TDocumentStorage aStorage)

 //

 // Test streaming CPlainText.

 //

 	{// Create the plain text components.

 	INFO_PRINTF1(_L("Streaming CPlainText"));

 	CPlainText* copy=CPlainText::NewL(aStorage);

 	CPlainText* testDoc=CPlainText::NewL(aStorage);

 	//

 	// Set the original - empty

 	INFO_PRINTF1(_L("empty."));

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 	//	

 	INFO_PRINTF1(_L("paragraph delimiter"));

 	TRAPD(r,testDoc->InsertL(0,CEditableText::EParagraphDelimiter));

 	test(r==KErrNone);

 	testStoreRestoreL(*copy,*testDoc);	

 	test(IsEqual(copy,testDoc));

 	//

 	// Next test with tons of text guaranteed to force segment break when using segmented storage.	

 	INFO_PRINTF1(_L("big text component"));

 	testDoc->InsertL(0,bigBuf);

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 	//

 	// Now test with field components.

 	INFO_PRINTF1(_L("big text doc with field components."));

 	TTestFieldFactoryCONVS factory;

 	testDoc->SetFieldFactory(&factory);

 	copy->SetFieldFactory(&factory);

 	CTextField* field=NULL;

 	TRAPD(ret,

 	field=factory.NewFieldL(KDateTimeFieldUid));

 	test(ret==KErrNone);

 	TRAP(ret,

 	testDoc->InsertFieldL(0,field,KDateTimeFieldUid));

 	test(ret==KErrNone);

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 	//

 	//

 	delete copy;

 	delete testDoc;

 	}

 void CT_CONVS::testGlobalTextL(CEditableText::TDocumentStorage aStorage)

 //

 // Test streaming CGlobalText.

 //

 	{// Create the plain text components.

 	INFO_PRINTF1(_L("Streaming CGlobalText"));

 	CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();

 	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();

 	// Set something interesting in the layers:

 	CParaFormat* paraFormat1=CParaFormat::NewL(); TParaFormatMask paraMask1;

 	TCharFormat charFormat1; TCharFormatMask charMask1;

 	paraFormat1->iHorizontalAlignment=CParaFormat::ECenterAlign; paraMask1.SetAttrib(EAttAlignment);

 	paraFormat1->iLeftMarginInTwips=4000; paraMask1.SetAttrib(EAttLeftMargin);

 	paraLayer->SetL(paraFormat1,paraMask1);

 	charFormat1.iFontSpec.iFontStyle.SetPosture(EPostureItalic); charMask1.SetAttrib(EAttFontPosture);

 	charFormat1.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); charMask1.SetAttrib(EAttFontStrokeWeight);

 	charLayer->SetL(charFormat1,charMask1);

 	//	

 	CGlobalText* copy=CGlobalText::NewL(paraLayer,charLayer,aStorage);

 	CGlobalText* testDoc=CGlobalText::NewL(paraLayer,charLayer,aStorage);

 //	Set the original - empty

 	INFO_PRINTF1(_L("empty."));

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 //	

 	INFO_PRINTF1(_L("paragraph delimiter"));

 	TRAPD(r,testDoc->InsertL(0,CEditableText::EParagraphDelimiter));

 	test(r==KErrNone);

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 //	Next test with tons of text guaranteed to force segment break when using segmented storage.	

 	INFO_PRINTF1(_L("big text component"));

 	testDoc->InsertL(0,bigBuf);

 	testStoreRestoreL(*copy,*testDoc);

 	test(IsEqual(copy,testDoc));

 	delete copy;

 	delete testDoc;

 	delete paraLayer;

 	delete charLayer;

 	delete paraFormat1;

 	}

 TInt CT_CONVS::LayerIsEqual(const CParaFormatLayer* aRestored,const CParaFormatLayer* aOriginal)

 //

 // Returns true if aRestored contents matches aOriginal contents.

 //

 	{

 	CParaFormat* restored=NULL;  TParaFormatMask rm;

 	CParaFormat* original=NULL;  TParaFormatMask om;

 	TRAPD(r,restored=CParaFormat::NewL());     test(r==KErrNone);

 	TRAP(r,original=CParaFormat::NewL());     test(r==KErrNone);

 	aOriginal->SenseL(original,om);

 	aRestored->SenseL(restored,rm);

 	test(original->IsEqual(*restored));

 	delete restored;

 	delete original;

 	return 1;

 	}

 TInt CT_CONVS::LayerIsEqual(const CCharFormatLayer* aRestored,const CCharFormatLayer* aOriginal)

 //

 // Returns true if aRestored contents matches aOriginal contents.

 //

 	{

 	TCharFormat restored;  TCharFormatMask rm;

 	TCharFormat original;  TCharFormatMask om;

 	aOriginal->Sense(original,om);

 	aRestored->Sense(restored,rm);

 	test(original.IsEqual(restored));

 	return 1;

 	}

 void CT_CONVS::testFmtLayerStoreL()

 //

 // Test the format layer StoreL().

 //

 	{

 	INFO_PRINTF1(_L("CParaFormatLayer"));

 //	Create test layers.

 	CParaFormatLayer* pfl1=NULL;

 	CParaFormatLayer* restored=NULL;

 	CParaFormat* pf1=NULL;

 	TRAPD(r,restored=CParaFormatLayer::NewL());     test(r==KErrNone);

 	// Force *restored* to allocate storage for iteself by storing a null layer.

 	TParaFormatMask rm;     rm.ClearAll(); CParaFormat* rpf=NULL;

 	restored->SetL(rpf,rm);

 	TRAP(r,pfl1=CParaFormatLayer::NewL());     test(r==KErrNone);

 	TRAP(r,pf1=CParaFormat::NewL());     test(r==KErrNone);

 	TParaFormatMask pm1;

 	pm1.SetAll();  // Sets all but the compound attributes.

 //	TEST ONE DEFAULT CASES

 	INFO_PRINTF1(_L("Default paragraph format values."));

 	TRAP(r,pfl1->SetL(pf1,pm1));     test(r==KErrNone);

 	testCopy(*restored,*pfl1);

 	test(LayerIsEqual(restored,pfl1));

 	test(restored->SenseBase()==pfl1->SenseBase());  // Both should default to based on NULL

 //	TEST TWO 

 	INFO_PRINTF1(_L("Setting all attributes"));

 	pf1->iLeftMarginInTwips=5000; pm1.ClearAll(); pm1.SetAttrib(EAttLeftMargin);

 	pf1->iRightMarginInTwips=5001; pm1.SetAttrib(EAttRightMargin);

 	pf1->iIndentInTwips=5002;pm1.SetAttrib(EAttIndent);

 	pf1->iHorizontalAlignment=CParaFormat::ERightAlign; pm1.SetAttrib(EAttAlignment);

 	pf1->iVerticalAlignment=CParaFormat::ECenterAlign; pm1.SetAttrib(EAttVerticalAlignment);

 	pf1->iLineSpacingInTwips=5003; pm1.SetAttrib(EAttLineSpacing);

 	pf1->iLineSpacingControl=CParaFormat::ELineSpacingAtLeastInTwips; pm1.SetAttrib(EAttLineSpacingControl);

 	pf1->iSpaceBeforeInTwips=5004; pm1.SetAttrib(EAttSpaceBefore);

 	pf1->iSpaceAfterInTwips=5005; pm1.SetAttrib(EAttSpaceAfter);

 	pf1->iKeepTogether=ETrue; pm1.SetAttrib(EAttKeepTogether);

 	pf1->iKeepWithNext=ETrue; pm1.SetAttrib(EAttKeepWithNext);

 	pf1->iStartNewPage=ETrue; pm1.SetAttrib(EAttStartNewPage);

 	pf1->iWidowOrphan=ETrue; pm1.SetAttrib(EAttWidowOrphan);

 	pf1->iWrap=EFalse; pm1.SetAttrib(EAttWrap);

 	pf1->iBorderMarginInTwips=5006; pm1.SetAttrib(EAttBorderMargin);

 	pf1->iDefaultTabWidthInTwips=5007; pm1.SetAttrib(EAttDefaultTabWidth);

 	// TopBorder

 	TParaBorder top;

 	top.iLineStyle=TParaBorder::ESolid;

 	top.iThickness=4;

 	top.iAutoColor=ETrue;

 	pf1->SetParaBorderL(CParaFormat::EParaBorderTop,top);

 	pm1.SetAttrib(EAttTopBorder);

 	// BottomBorder

 	TParaBorder bottom;	

 	bottom.iLineStyle=TParaBorder::ESolid;

 	bottom.iThickness=4;

 	bottom.iAutoColor=ETrue;

 	pf1->SetParaBorderL(CParaFormat::EParaBorderBottom,bottom);

 	pm1.SetAttrib(EAttBottomBorder);

 	// LeftBorder

 	TParaBorder left;

 	left.iLineStyle=TParaBorder::ESolid;

 	left.iThickness=4;

 	left.iAutoColor=ETrue;

 	pf1->SetParaBorderL(CParaFormat::EParaBorderLeft,left);

 	pm1.SetAttrib(EAttLeftBorder);

 	// RightBorder

 	TParaBorder right;

 	right.iLineStyle=TParaBorder::ESolid;

 	right.iThickness=4;

 	top.iAutoColor=ETrue;

 	pf1->SetParaBorderL(CParaFormat::EParaBorderRight,right);

 	pm1.SetAttrib(EAttRightBorder);

 	// Bullet

 	pf1->iBullet=new(ELeave)TBullet;

 	TUint charCode=5008;

 	pf1->iBullet->iCharacterCode=(TUint8)charCode;

 	pf1->iBullet->iHeightInTwips=5009;

 	pf1->iBullet->iTypeface.iName=_L("Duncan");

 	pf1->iBullet->iTypeface.SetIsProportional(EFalse);

 	pf1->iBullet->iTypeface.SetIsSerif(EFalse);

 	pm1.SetAttrib(EAttBullet);

 	// 2 Tab Stops.

 	TTabStop tab1,tab2;

 	tab1.iTwipsPosition=5010; tab1.iType=TTabStop::ERightTab;

 	tab2.iTwipsPosition=5011; tab2.iType=TTabStop::ECenteredTab;

 	pf1->StoreTabL(tab1);

 	pf1->StoreTabL(tab2);

 	pm1.SetAttrib(EAttTabStop);

 //

 	TRAP(r,pfl1->SetL(pf1,pm1));

 	testCopy(*restored,*pfl1);

 	test(LayerIsEqual(restored,pfl1));

 	test(restored->SenseBase()==pfl1->SenseBase());  // Both should default to based on NULL

 //

 	delete pf1;

 	delete pfl1;

 	delete restored;

 //

 //	Now the CCharFormatLayer Store/Restore

 //

 	INFO_PRINTF1(_L("CCharFormatLayer"));

 // 	

 	INFO_PRINTF1(_L("Setting all attributes"));

 //	Create test layers.

 	CCharFormatLayer* cfl1=NULL;

 	CCharFormatLayer* cRestored=NULL;

 	TCharFormat cf1; TCharFormatMask cm1;

 //

 	TRAP(r,cRestored=CCharFormatLayer::NewL());     test(r==KErrNone);

 	// Force *restored* to allocate storage for iteself by storing a null layer.

 	TCharFormatMask rcm;     rcm.ClearAll(); TCharFormat rcf;

 	cRestored->SetL(rcf,rcm);

 //

 	TRAP(r,cfl1=CCharFormatLayer::NewL());     test(r==KErrNone);

 //	

 	TRgb color(20,20,20);

 	cf1.iFontPresentation.iTextColor=color;	cm1.SetAttrib(EAttColor);

 	cf1.iFontSpec.iTypeface.iName=_L("DUNCANXZE");

 	cf1.iFontSpec.iTypeface.SetIsProportional(ETrue);	cm1.SetAttrib(EAttFontTypeface);

 	cf1.iFontSpec.iTypeface.SetIsSerif(EFalse);

     cf1.iFontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap);

 	cf1.iFontSpec.iHeight=6000;	cm1.SetAttrib(EAttFontHeight);

 	cf1.iFontSpec.iFontStyle.SetPosture(EPostureItalic);	cm1.SetAttrib(EAttFontPosture);

 	cf1.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);	cm1.SetAttrib(EAttFontStrokeWeight);

 	cf1.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSuperscript);	cm1.SetAttrib(EAttFontPrintPos);

 	cf1.iFontPresentation.iUnderline=EUnderlineOn;	cm1.SetAttrib(EAttFontUnderline);

 	cf1.iFontPresentation.iStrikethrough=EStrikethroughOn;	cm1.SetAttrib(EAttFontStrikethrough);

 	cf1.iFontPresentation.iHighlightColor=color;  cm1.SetAttrib(EAttFontHighlightColor);

 	cf1.iFontPresentation.iHighlightStyle=TFontPresentation::EFontHighlightNormal;  cm1.SetAttrib(EAttFontHighlightStyle);

 //

 	TRAP(r,cfl1->SetL(cf1,cm1));

 	test(r==KErrNone);

 	testCopy(*cRestored,*cfl1);

 	test(LayerIsEqual(cRestored,cfl1));

 	TCharFormat rfmt;  

     TCharFormatMask rmask;

 	cRestored->Sense(rfmt, rmask);

     test(rfmt.iFontSpec.iFontStyle.BitmapType() == EMonochromeGlyphBitmap);

 //

 	delete cfl1;

 	delete cRestored;

 	}

 TInt CT_CONVS::ChainIsEqual(const CParaFormatLayer* aCopy,const CParaFormatLayer* aOriginal)

 //

 // Tests that the restored chain is identical to the original chain.

 //

 	{

 	TInt origChainCount=aOriginal->ChainCount();

 	/*TInt copyChainCount=*/aCopy->ChainCount();

 //	Check the chain heads are equal.

 	test(LayerIsEqual(aCopy,aOriginal));

 	TInt descendantCount=origChainCount-1;

 	const CFormatLayer* nextCopyLayer=aCopy->SenseBase();

 	const CFormatLayer* nextOrigLayer=aOriginal->SenseBase();

 	for (TInt loop=0;loop<descendantCount;loop++)

 		{

 		test(LayerIsEqual((CParaFormatLayer*)nextCopyLayer,(CParaFormatLayer*)nextOrigLayer));

 		nextCopyLayer=nextCopyLayer->SenseBase();

 		nextOrigLayer=nextOrigLayer->SenseBase();

 		}

 	return 1;

 	}

 TInt CT_CONVS::ChainIsEqual(const CCharFormatLayer* aCopy,const CCharFormatLayer* aOriginal)

 //

 // Tests that the restored chain is identical to the original chain.

 //

 	{

 	TInt origChainCount=aOriginal->ChainCount();

 	/*TInt copyChainCount=*/aCopy->ChainCount();

 //	Check the chain heads are equal.

 	test(LayerIsEqual(aCopy,aOriginal));

 	TInt descendantCount=origChainCount-1;

 	const CFormatLayer* nextCopyLayer=aCopy->SenseBase();

 	const CFormatLayer* nextOrigLayer=aOriginal->SenseBase();

 	for (TInt loop=0;loop<descendantCount;loop++)

 		{

 		test(LayerIsEqual((CCharFormatLayer*)nextCopyLayer,(CCharFormatLayer*)nextOrigLayer));

 		nextCopyLayer=nextCopyLayer->SenseBase();

 		nextOrigLayer=nextOrigLayer->SenseBase();

 		}

 	return 1;

 	}

 void CT_CONVS::DoParaChainL()

 //

 // Tests the streaming of a chain of format layers

 //

 	{

 	INFO_PRINTF1(_L("Re/StoreChainL()"));

 	INFO_PRINTF1(_L("CParaFormatLayer"));

 //	Create the chain of para format layers.

 	CParaFormatLayer* l1=CParaFormatLayer::NewL();

 	CParaFormatLayer* l2=CParaFormatLayer::NewL();

 	CParaFormatLayer* l3=CParaFormatLayer::NewL();

 	CParaFormatLayer* l4=CParaFormatLayer::NewL();

 //	Chain together.

 	l1->SetBase(l2);

 	l2->SetBase(l3);

 	l3->SetBase(l4);

 //	Create head of restored format stream, and force it to get storage.	

 	CParaFormatLayer* restoredChainHead=CParaFormatLayer::NewL();

 	CParaFormat* restoredParaFormat=CParaFormat::NewL();

 	TParaFormatMask restoredParaMask;

 	restoredParaMask.ClearAll();

 	restoredChainHead->SetL(restoredParaFormat,restoredParaMask);

 //	General paraformat and its mask.

 	CParaFormat* paraFormat=CParaFormat::NewL();

 	TParaFormatMask paraMask;

 	paraMask.ClearAll();

 //	Set layer one stuff

 	TTabStop tab1,tab2;

 	tab1.iTwipsPosition=5000;	tab2.iTwipsPosition=5001;

 	tab1.iType=TTabStop::ERightTab;	tab2.iType=TTabStop::ECenteredTab;

 	paraFormat->StoreTabL(tab1);

 	paraFormat->StoreTabL(tab2);

 	paraMask.SetAttrib(EAttTabStop);

 	l1->SetL(paraFormat,paraMask);

 	paraMask.ClearAll();

 //	Set layer two stuff

 	TParaBorder top1;

 	top1.iLineStyle=TParaBorder::ESolid;

 	top1.iThickness=3;

 	top1.iAutoColor=ETrue;

 	paraFormat->SetParaBorderL(CParaFormat::EParaBorderTop,top1);

 	paraMask.SetAttrib(EAttTopBorder);

 	l2->SetL(paraFormat,paraMask);

 	paraMask.ClearAll();

 //	Set the layer 3 stuff.

 	paraFormat->iBullet=new(ELeave)TBullet;

 	paraFormat->iBullet->iTypeface.iName=_L("SKELTON");

 	paraFormat->iBullet->iTypeface.SetIsProportional(EFalse);

 	paraFormat->iBullet->iTypeface.SetIsSerif(EFalse);

 	paraFormat->iBullet->iHeightInTwips=3003;

 	paraFormat->iBullet->iCharacterCode=32;

 	paraMask.SetAttrib(EAttBullet);

 	l3->SetL(paraFormat,paraMask);

 	paraMask.ClearAll();

 // Set the layer 4 stuff.

 	paraFormat->iHorizontalAlignment=CParaFormat::EJustifiedAlign;	paraMask.SetAttrib(EAttAlignment);

 	paraFormat->iSpaceAfterInTwips=6000;			paraMask.SetAttrib(EAttSpaceAfter);

 	paraFormat->iKeepTogether=ETrue;			paraMask.SetAttrib(EAttKeepTogether);

 	l4->SetL(paraFormat,paraMask);

 // NOW DO IT

 	testCopyChain(*restoredChainHead,*l1,0,(const CFormatLayer*)NULL);

 	TInt restoredChainCount=restoredChainHead->ChainCount();

 	test(ChainIsEqual(restoredChainHead,l1));

 //	DESTROY STUFF

 	CParaFormatLayer* current=restoredChainHead;

 	CParaFormatLayer* next=(CParaFormatLayer*)restoredChainHead->SenseBase();

 	delete current;

 	for (TInt loop=0;loop<restoredChainCount-1;loop++)	

 		{

 		current=next;

 		next=(CParaFormatLayer*)current->SenseBase();

 		delete current;

 		}

 	delete l1;

 	delete l2;

 	delete l3;

 	delete l4;

 	delete paraFormat;

 	delete restoredParaFormat;

 	}

 void CT_CONVS::DoCharChainL()

 //

 //

 //

 	{

 	INFO_PRINTF1(_L("CCharFormatLayer"));

 //	Create the chain of character format layers.

 	CCharFormatLayer* cl1=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl2=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl3=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl4=CCharFormatLayer::NewL();

 //	Chain together.

 	cl1->SetBase(cl2);

 	cl2->SetBase(cl3);

 	cl3->SetBase(cl4);

 //	Create head of restored format stream, and force it to get storage.	

 	CCharFormatLayer* rChar=CCharFormatLayer::NewL();

 	TCharFormat restoredCharFormat;

 	TCharFormatMask restoredCharMask;

 	restoredCharMask.ClearAll();

 	rChar->SetL(restoredCharFormat,restoredCharMask);

 //	General charformat and its mask.

 	TCharFormat charFormat;	TCharFormatMask charMask;

 	charMask.ClearAll();

 //	Set layer one stuff

 	charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);	charMask.SetAttrib(EAttFontStrokeWeight);

 	charFormat.iFontSpec.iFontStyle.SetPosture(EPostureItalic);	charMask.SetAttrib(EAttFontPosture);

 	charFormat.iFontPresentation.iUnderline=EUnderlineOn;	charMask.SetAttrib(EAttFontUnderline);

 	cl1->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set layer two stuff

 	charFormat.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript);	charMask.SetAttrib(EAttFontPrintPos);

 	cl2->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set the layer 3 stuff.

 	charFormat.iFontPresentation.iStrikethrough=EStrikethroughOn;	charMask.SetAttrib(EAttFontStrikethrough);

 	cl3->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set the layer 4 stuff.

 	charFormat.iFontSpec.iTypeface.iName=_L("Arial");

 	charFormat.iFontSpec.iHeight=200;

 	charMask.SetAttrib(EAttFontHeight);

 	charMask.SetAttrib(EAttFontTypeface);

 	cl4->SetL(charFormat,charMask);

 //	NOW DO IT

 	INFO_PRINTF1(_L("Chain 4 layers deep, terminating on a based on NULL"));

 	testCopyChain(*rChar,*cl1,0,(const CFormatLayer*)NULL);

 	TInt restoredChainCount=rChar->ChainCount();

 	test(ChainIsEqual(rChar,cl1));

 //	DESTROY STUFF

 	CCharFormatLayer* chCurrent=rChar;

 	CCharFormatLayer* chNext=(CCharFormatLayer*)rChar->SenseBase();

 	delete chCurrent;

 	for (TInt loop=0;loop<restoredChainCount-1;loop++)	

 		{

 		chCurrent=chNext;

 		chNext=(CCharFormatLayer*)chCurrent->SenseBase();

 		delete chCurrent;

 		}

 	delete cl1;

 	delete cl2;

 	delete cl3;

 	delete cl4;

 	}

 void CT_CONVS::DoCharChainVariant1()

 //

 // Case 2: Where the chain does not terminate at a NULL link.

 //

 	{

 //	Create the chain of character format layers.

 	CCharFormatLayer* cl1=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl2=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl3=CCharFormatLayer::NewL();

 	CCharFormatLayer* cl4=CCharFormatLayer::NewL();

 //	Chain together.

 	cl1->SetBase(cl2);

 	cl2->SetBase(cl3);

 	cl3->SetBase(cl4);

 //	Create head of restored format stream, and force it to get storage.	

 	CCharFormatLayer* rChar=CCharFormatLayer::NewL();

 	TCharFormat restoredCharFormat;

 	TCharFormatMask restoredCharMask;

 	restoredCharMask.ClearAll();

 	rChar->SetL(restoredCharFormat,restoredCharMask);

 //	General charformat and its mask.

 	TCharFormat charFormat;	TCharFormatMask charMask;

 	charMask.ClearAll();

 //	Set layer one stuff

 	charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);	charMask.SetAttrib(EAttFontStrokeWeight);

 	charFormat.iFontSpec.iFontStyle.SetPosture(EPostureItalic);	charMask.SetAttrib(EAttFontPosture);

 	charFormat.iFontPresentation.iUnderline=EUnderlineOn;	charMask.SetAttrib(EAttFontUnderline);

 	cl1->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set layer two stuff

 	charFormat.iFontSpec.iFontStyle.SetPrintPosition(EPrintPosSubscript);	charMask.SetAttrib(EAttFontPrintPos);

 	cl2->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set the layer 3 stuff.

 	charFormat.iFontPresentation.iStrikethrough=EStrikethroughOn;	charMask.SetAttrib(EAttFontStrikethrough);

 	cl3->SetL(charFormat,charMask);

 	charMask.ClearAll();

 //	Set the layer 4 stuff.

 	charFormat.iFontSpec.iTypeface.iName=_L("Arial");

 	charFormat.iFontSpec.iHeight=200;

 	charMask.SetAttrib(EAttFontHeight);

 	charMask.SetAttrib(EAttFontTypeface);

 	cl4->SetL(charFormat,charMask);

 //	NOW DO IT

 	INFO_PRINTF1(_L("Chain 3 layers deep, terminating on a non-NULL based-on"));

 	testCopyChain(*rChar,*cl1,1,(const CFormatLayer*)cl4);

 	TInt restoredChainCount=rChar->ChainCount();

 	test(ChainIsEqual(rChar,cl1));

 //	DESTROY STUFF

 	CCharFormatLayer* chCurrent=rChar;

 	CCharFormatLayer* chNext=(CCharFormatLayer*)rChar->SenseBase();

 	delete chCurrent;

 	for (TInt loop=0;loop<restoredChainCount-2;loop++)	

 		{

 		chCurrent=chNext;

 		chNext=(CCharFormatLayer*)chCurrent->SenseBase();

 		delete chCurrent;

 		}

 	delete cl1;

 	delete cl2;

 	delete cl3;

 	delete cl4;

 	}

 void CT_CONVS::testFmtLayerStoreChainL()

 //

 // Controls the testing of the chainig stuff.

 //

 	{

 	DoParaChainL();

 	DoCharChainL();

 	DoCharChainVariant1();

 //	DoCharChainVariant2();  TO BE IMPLEMENTED

 //	doCharChainVariant3();	TO BE IMPLEMENTED

 	}

 void CT_CONVS::testFmtLayerL()

 //

 // Tests the streaming of format layers.

 //

 	{

 	testFmtLayerStoreL();

 	testFmtLayerStoreChainL();

 	}

 void CT_CONVS::setupCleanup()

 //

 // Initialise the cleanup stack.

 //

     {

 	TheTrapCleanup=CTrapCleanup::New();

 	TRAPD(r,\

 		{\

 		for (TInt i=KTestCleanupStack;i>0;i--)\

 			CleanupStack::PushL((TAny*)1);\

 		test(r==KErrNone);\

 		CleanupStack::Pop(KTestCleanupStack);\

 		});

 	}

 void CT_CONVS::DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		if(fsSession.Entry(aFullName, entry) == KErrNone)

 			{

 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

 				}

 			}

 		fsSession.Close();

 		}

 	else

 		{

 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

 		}

 	}

 CT_CONVS::CT_CONVS()

     {

     SetTestStepName(KTestStep_T_CONVS);

     }

 TVerdict CT_CONVS::doTestStepL()

     {

     SetTestStepResult(EFail);

     INFO_PRINTF1(_L("T_CONVS - EditableText Persistence"));

     setupCleanup();

     __UHEAP_MARK;

     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-LEGACY-T_CONVS-0001 EText components using Flat Storage "));

     TRAPD(error1, testPlainTextL(CEditableText::EFlatStorage));

     TRAPD(error2, testGlobalTextL(CEditableText::EFlatStorage));

     INFO_PRINTF1(_L("EText components using Segmented storage"));

     TRAPD(error3, testPlainTextL(CEditableText::ESegmentedStorage));

     TRAPD(error4, testGlobalTextL(CEditableText::ESegmentedStorage));

     INFO_PRINTF1(_L("Format Layer components"));

     TRAPD(error5, testFmtLayerL());

     __UHEAP_MARKEND;

     DeleteDataFile(KOutputFile);  //deletion of data files must be before call to End() - DEF047652

     delete TheTrapCleanup;

     if(error1 == KErrNone && error2 == KErrNone && error3 == KErrNone && error4 == KErrNone && error5 == KErrNone)

         {

         SetTestStepResult(EPass);

         }

     return TestStepResult();

     }