/*

 * 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 <txtrich.h>

 #include <txtfmlyr.h>

 #include <s32mem.h>

 #include <s32file.h>

 #include <flddef.h>

 #include <fldbltin.h>

 #include "../incp/T_PMLPAR.H"

 #include "T_CONVRT.h"

 #define test(cond)											\

 	{														\

 	TBool __bb = (cond);									\

 	TEST(__bb);												\

 	if (!__bb)												\

 		{													\

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

 		User::Leave(1);										\

 		}													\

 	}

 #define UNUSED_VAR(a) a = a

 const TInt KTestCleanupStack=0x20;

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 //

 LOCAL_D CRichText* TheText=NULL;

 LOCAL_D CParaFormatLayer* TheGlobalParaLayer=NULL;

 LOCAL_D CCharFormatLayer* TheGlobalCharLayer=NULL;

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

 class TTestFieldFactoryCONVRT : 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* TTestFieldFactoryCONVRT::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;

 	}

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

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

 template <class T>

 void CT_CONVRT::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();

     }

 TInt CT_CONVRT::IsEqual(const CEditableText* aCopy,const CEditableText* 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<copy.Length(); offset++)

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

 		lengthRead+=copy.Length();

 		}

 	test(lengthRead==lengthOfOriginal+1);

 	return 1;

 	}

 void CT_CONVRT::DoTestRichTextL()

 //

 // Test streaming CRichText.

 //

 	{// Create the global text components.

 	const TInt KSmallestTextBuffer=1;

 	CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();

 	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();

 	//	

 	CRichText* theCopy=NULL;

 	//

 	TInt biggest;

 	TInt size=User::Available(biggest); 

 	//

 	TRAPD(ret,

 	theCopy=CRichText::NewL(paraLayer,charLayer,CEditableText::ESegmentedStorage,KSmallestTextBuffer));

 	//

 	TInt newsize=User::Available(biggest);

 	TInt footprint=size-newsize;

 	//

 	size=User::Available(biggest);

 	CGlobalText* gText=NULL;

 	TRAP(ret,

 	gText=CGlobalText::NewL(paraLayer,charLayer,CEditableText::ESegmentedStorage,KSmallestTextBuffer));

 	newsize=User::Available(biggest);

 	TInt globalPrint=size-newsize;

 	TBuf<50> buf;

 	buf.Format(_L("Empty rich text takes: %d bytes\n"),footprint);

 	INFO_PRINTF1(buf);

 	buf.Format(_L("Empty global text takes: %d bytes\n"),globalPrint);

 	INFO_PRINTF1(buf);

 //	test.Getch();

 	delete gText;

 	//

 	// Now add a text field to this.

 	TTestFieldFactoryCONVRT factory;

 	TheText->SetFieldFactory(&factory);

 	theCopy->SetFieldFactory(&factory);

 	CTextField* field=NULL;

 	TRAP(ret,

 	field=factory.NewFieldL(KDateTimeFieldUid));

 	test(ret==KErrNone);

 	TRAP(ret,

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

 	test(ret==KErrNone);

 	TRAP(ret,

 	TheText->UpdateFieldL(0));

 	test(ret==KErrNone);

 	//

 	// Do the store/restore and test

 	testStoreRestoreL(*theCopy,*TheText);

 	test(IsEqual(theCopy,TheText));

 	theCopy->Reset();  // lets me see inside the invariant;

 	delete theCopy;

 	delete paraLayer;

 	delete charLayer;

 	}

 void CT_CONVRT::LoadIntoText(TFileName& aFileName)

 //

 	{

 	CParser* myParser=NULL;

 	TRAPD(ret,

 	myParser=CParser::NewL());

 	test(ret == KErrNone);

 	TRAP(ret,

 	TheText=myParser->ParseL(aFileName));

 	test(ret == KErrNone);

 	TheGlobalParaLayer=(CParaFormatLayer*)TheText->GlobalParaFormatLayer();

 	TheGlobalCharLayer=(CCharFormatLayer*)TheText->GlobalCharFormatLayer();

 	delete myParser;

 	}

 void CT_CONVRT::KillText()

 //

 	{

 	delete TheText;

 	}

 void CT_CONVRT::KillLayers()

 	{

 	delete TheGlobalParaLayer;

 	delete TheGlobalCharLayer;

 	}

 void CT_CONVRT::Reset()

 //

 	{

 	KillText();

 	KillLayers();

 	}

 void CT_CONVRT::GoL()

 //

 	{

 	INFO_PRINTF1(_L("Rich Text of Shared Para Formats Only"));

 	TFileName fileName=_L("z:\\test\\app-framework\\etext\\shared.pml");

 	LoadIntoText(fileName);

 	TBool hasMarkupData=TheText->HasMarkupData();

 	test(hasMarkupData);

 	DoTestRichTextL();

 	Reset();

 	//

 	INFO_PRINTF1(_L("Rich Text with specific character formatting"));

 	fileName=_L("z:\\test\\app-framework\\etext\\test1.pml");

 	LoadIntoText(fileName);

 	hasMarkupData=TheText->HasMarkupData();

 	test(hasMarkupData);

 	DoTestRichTextL();

 	Reset();

 	}

 void CT_CONVRT::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_CONVRT::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_CONVRT::CT_CONVRT()

     {

     SetTestStepName(KTestStep_T_CONVRT);

     }

 TVerdict CT_CONVRT::doTestStepL()

     {

     SetTestStepResult(EFail);

     setupCleanup();

     __UHEAP_MARK;

     INFO_PRINTF1(_L("T_CONVRT - Rich Text Persistence"));

     INFO_PRINTF1(_L("Persisting Rich Text"));

     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-LEGACY-T_CONVRT-0001 "));

     TRAPD(error1, GoL());

     __UHEAP_MARKEND;

     delete TheTrapCleanup;

     if(error1 == KErrNone)

         {

         SetTestStepResult(EPass);

         }

     return TestStepResult();

     }