/*
* 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 <s32file.h>
#include <flddef.h>
#include <fldbase.h>
#include <fldset.h>
#include "TESTFAC.H"
#include "T_STREAM.h"

#define test(cond)											\
	{														\
	TBool __bb = (cond);									\
	TEST(__bb);												\
	if (!__bb)												\
		{													\
		ERR_PRINTF1(_L("ERROR: Test Failed"));				\
		User::Leave(1);										\
		}													\
	}

const TInt KTestCleanupStack=0x20;

LOCAL_D CTrapCleanup* TheTrapCleanup;
LOCAL_D CTextFieldSet* TheFieldSetOriginal;
LOCAL_D CTextFieldSet* TheFieldSetCopy;
LOCAL_D TTestFieldFactory* TheFactory;

_LIT(KTFieldOutputFile, "c:\\etext\\tfield.tst");
// Test Picture persistance.
void CT_STREAM::testStoreRestore(CTextFieldSet* aCopy,const CTextFieldSet* aOriginal)
    {
	// set up the store
	RFs	theFs;
	theFs.Connect();
	theFs.Delete(KTFieldOutputFile);
	theFs.MkDirAll(KTFieldOutputFile);
	CFileStore* theStore=CDirectFileStore::CreateL(theFs, KTFieldOutputFile, 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_STREAM::testCopyPaste(T* aCopy, T* aOriginal,TInt aCopyPos,TInt aLen,TInt aPastePos,TInt aPasteLen)
// Copy part of anOriginal to aCopy using memory-based streams.
//
	{
	// set up the store
	RFs	theFs;
	theFs.Connect();
	CFileStore* theStore=CDirectFileStore::ReplaceL(theFs,KTFieldOutputFile,EFileRead|EFileWrite);
	CleanupStack::PushL(theStore);
	theStore->SetTypeL(KDirectFileStoreLayoutUid);
	//
	// Copy anOriginal out to the buffer
	TStreamId id(0);
	TRAPD(ret,id=aOriginal->CopyToStoreL(*theStore,aCopyPos,aLen));
		test(ret==KErrNone);
	//
	// paste into the copy
	TRAP(ret,aCopy->PasteFromStoreL(*theStore,id,aPastePos,aPasteLen));
		test(ret==KErrNone);
	//
	// tidy up
	CleanupStack::PopAndDestroy();  // theStore
	theFs.Close();

	}


TBool CT_STREAM::IsEqual(const CTextFieldSet* aCopy,const CTextFieldSet* anOriginal)
//
// Returns true if aCopy contents matches anOriginal contents.
//
	{
	// test the num chars and num fields
	TInt charCount = anOriginal->CharCount();
	TInt fieldCount = anOriginal->FieldCount();
	test(charCount==aCopy->CharCount());
	test(fieldCount==aCopy->FieldCount());

	// test each entry in the array
	for (TInt pos=0 ; pos<charCount ;)
		{
		TFindFieldInfo infoOrig,infoCopy;
		anOriginal->FindFields(infoOrig,pos,charCount-pos);
		aCopy->FindFields(infoCopy,pos,charCount-pos);
		test(infoOrig==infoCopy);
		pos += infoOrig.iFirstFieldPos+infoOrig.iFirstFieldLen;
		if (infoOrig.iFieldCountInRange==0)
			break;
		}

	return ETrue;
	}


TBool CT_STREAM::UpdateField(TInt aPos,CTextFieldSet* aSet)
	{
	// find out which field aPos is in
	TFindFieldInfo info;
	TBool ret;
	ret=aSet->FindFields(info,aPos);
		test(ret);
	// get the new value
	HBufC* buf = HBufC::NewL(5); 
	CleanupStack::PushL(buf);
 	TInt err=aSet->NewFieldValueL(buf,aPos); 
		test(err==KErrNone);
	// Notify FieldSet of update
	aSet->NotifyFieldUpdate(aPos,buf->Length());
	// tidy up
	CleanupStack::PopAndDestroy();
	return ret;
	}


void CT_STREAM::test2()
// Streams an empty field set
//
	{
	INFO_PRINTF1(_L("- streaming of a default FieldSet (no fields)"));
	testStoreRestore(TheFieldSetCopy,TheFieldSetOriginal);
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test3()
// Streams a field set containing 100 chars & 1 field
//
	{
	INFO_PRINTF1(_L("- streaming with a field"));

	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	ret=UpdateField(10,TheFieldSetOriginal);
		test(ret);

	// test streaming
	testStoreRestore(TheFieldSetCopy,TheFieldSetOriginal);
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test4()
// Streams a field set into a non-empty target
//
	{
	INFO_PRINTF1(_L("- streaming into a non-empty target"));

	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	ret=UpdateField(10,TheFieldSetOriginal);
		test(ret);

	// insert a block of text into the copy
	TheFieldSetCopy->NotifyInsertion(0,40); // pos=0, len=40
	// insert two fields into the copy
	CTextField* field2 = TheFieldSetCopy->NewFieldL(KDummyFieldUid);
	CTextField* field3 = TheFieldSetCopy->NewFieldL(KDummyFieldUid);
	ret=TheFieldSetCopy->InsertFieldL(20,field2,KDummyFieldUid); 
		test(ret==KErrNone);
	ret=TheFieldSetCopy->InsertFieldL(30,field3,KDummyFieldUid); 
		test(ret==KErrNone);
	ret=UpdateField(20,TheFieldSetCopy);
		test(ret);
	ret=UpdateField(33,TheFieldSetCopy);
		test(ret);

	// test streaming
	testStoreRestore(TheFieldSetCopy,TheFieldSetOriginal);
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test5()
// Streams a field set containing an out of date field
//
	{
	INFO_PRINTF1(_L("- streaming an out of date field"));

	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	ret=UpdateField(10,TheFieldSetOriginal);
		test(ret);
	// invalidate the field
	TheFieldSetOriginal->NotifyInsertion(11,7); // pos=11, len=7

	// test streaming
	testStoreRestore(TheFieldSetCopy,TheFieldSetOriginal);
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test6()
// Tests that copy/paste methods exist
//
	{
	INFO_PRINTF1(_L("- testing copy/paste methods with empty array"));
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,0,0,0); // copyPos,Len,PastePos
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test7()
// Tests copy/paste methods in detail
//
	{
	INFO_PRINTF1(_L("- testing copy/paste methods in detail"));
	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	TBool ok=UpdateField(10,TheFieldSetOriginal);
		test(ok);
		test(TheFieldSetOriginal->CharCount()==103);
	// copy out of that into an empty array
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,15,0); // copyPos,Len,PastePos
	// check that the contents of the array are as expected
	TFindFieldInfo info;
	TheFieldSetCopy->FindFields(info,0,15);
		test(TheFieldSetCopy->CharCount()==15);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==5);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->Reset();
	// test copying part of a field
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,6,0); // copyPos,Len,PastePos
	TheFieldSetCopy->FindFields(info,0,6);
		test(TheFieldSetCopy->CharCount()==6);
		test(TheFieldSetCopy->FieldCount()==0);
		test(info.iFieldCountInRange==0);
	TheFieldSetCopy->Reset();
	// test copying exactly one field
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,3,0); // copyPos,Len,PastePos
	TheFieldSetCopy->FindFields(info,0,3);
		test(TheFieldSetCopy->CharCount()==3);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==0);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->Reset();
	// test pasting into text in a non-empty array
	TheFieldSetCopy->NotifyInsertion(0,50); // pos=0, len=50
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,15,10); // copyPos,Len,PastePos
	TheFieldSetCopy->FindFields(info,0,65);
		test(TheFieldSetCopy->CharCount()==65);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==15);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->Reset();
	// test pasting into a field
	TheFieldSetCopy->NotifyInsertion(0,50); // pos=0, len=50
	field=TheFieldSetCopy->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	ret=TheFieldSetCopy->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	ok=UpdateField(10,TheFieldSetCopy);
		test(ok);
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,15,11); // copyPos,Len,PastePos
	TheFieldSetCopy->FindFields(info,0,68);
		test(TheFieldSetCopy->CharCount()==68);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==10);
		test(info.iFirstFieldLen==18);
	TheFieldSetCopy->Reset();
	// test pasting at the start & end of a field
	TheFieldSetCopy->NotifyInsertion(0,10); // pos=0, len=10
	field=TheFieldSetCopy->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	ret=TheFieldSetCopy->InsertFieldL(5,field,KDummyFieldUid); // pos=5
		test(ret==KErrNone);
	ok=UpdateField(5,TheFieldSetCopy);
		test(ok);
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,3,8); // copyPos,Len,PastePos
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,3,5); // copyPos,Len,PastePos
	TheFieldSetCopy->FindFields(info,0,19);
		test(TheFieldSetCopy->CharCount()==19);
		test(TheFieldSetCopy->FieldCount()==3);
		test(info.iFieldCountInRange==3);
		test(info.iFirstFieldPos==5);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->FindFields(info,8,11);
		test(info.iFieldCountInRange==2);
		test(info.iFirstFieldPos==8);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->FindFields(info,11,8);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==11);
		test(info.iFirstFieldLen==3);
	// tidy up
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test8()
// Tests paste method with restricted target length
//
	{
	INFO_PRINTF1(_L("- testing paste method with restricted length"));
	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert 2 fields into the original
	// 1...
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	TBool ok=UpdateField(10,TheFieldSetOriginal);
		test(ok);
	// 2..
	field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	ret=TheFieldSetOriginal->InsertFieldL(20,field,KDummyFieldUid); // pos=20
		test(ret==KErrNone);
	ok=UpdateField(20,TheFieldSetOriginal);
		test(ok);
	// paste part of original into copy with length greater than required
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,5,0,7); // copyPos,Len,PastePos,PasteLen
	TFindFieldInfo info;
	TheFieldSetCopy->FindFields(info,0,5);
		test(TheFieldSetCopy->CharCount()==5);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==0);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->Reset();
	// paste part of original into copy with length equal to that required
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,5,0,5); // copyPos,Len,PastePos,PasteLen
	TheFieldSetCopy->FindFields(info,0,5);
		test(TheFieldSetCopy->CharCount()==5);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==0);
		test(info.iFirstFieldLen==3);
	TheFieldSetCopy->Reset();
	// paste part of original into copy with length zero
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,10,5,0,0); // copyPos,Len,PastePos,PasteLen
		test(TheFieldSetCopy->CharCount()==0);
		test(TheFieldSetCopy->FieldCount()==0);
	TheFieldSetCopy->Reset();
	// paste part of original into copy with length st field is chopped
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,10,0,6); // copyPos,Len,PastePos,PasteLen
	TheFieldSetCopy->FindFields(info,0,6);
		test(TheFieldSetCopy->CharCount()==6);
		test(TheFieldSetCopy->FieldCount()==0);
		test(info.iFieldCountInRange==0);
	TheFieldSetCopy->Reset();
	// paste part of original into copy with length st one field is left off, the other pasted in
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,20,0,10); // copyPos,Len,PastePos,PasteLen
	TheFieldSetCopy->FindFields(info,0,10);
		test(TheFieldSetCopy->CharCount()==10);
		test(TheFieldSetCopy->FieldCount()==1);
		test(info.iFieldCountInRange==1);
		test(info.iFirstFieldPos==5);
		test(info.iFirstFieldLen==3);
	// tidy up
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::test9()
// Tests paste into set with no field factory
// Should convert all pasted fields to text...
//
	{
	INFO_PRINTF1(_L("- testing paste into set with no field factory"));
	TheFieldSetCopy->SetFieldFactory(NULL);
	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDummyFieldUid);
		test(field!=NULL);
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDummyFieldUid); // pos=10
		test(ret==KErrNone);
	TBool ok=UpdateField(10,TheFieldSetOriginal);
		test(ok);
	// paste part of original into copy
	testCopyPaste(TheFieldSetCopy,TheFieldSetOriginal,5,25,0); // copyPos,Len,PastePos
	TFindFieldInfo info;
	TheFieldSetCopy->FindFields(info,0,25);
		test(TheFieldSetCopy->CharCount()==25);
		test(TheFieldSetCopy->FieldCount()==0);
	// tidy up
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	TheFieldSetCopy->SetFieldFactory(TheFactory);
	}


void CT_STREAM::test10()
// Streams a field set containing 100 chars & 1 field
//
	{
	INFO_PRINTF1(_L("- streaming CDateTimeField"));

	// insert a block of text into the original
	TheFieldSetOriginal->NotifyInsertion(0,100); // pos=0, len=100
	// insert a field into the original
	CTextField* field=TheFieldSetOriginal->NewFieldL(KDateTimeFieldUid);
		test(field!=NULL);
	TBuf<14> buff = _L("%-A%*I%:1%T%+A");
	((CDateTimeField*)field)->SetFormat(buff); // 01:53pm
	TInt ret=TheFieldSetOriginal->InsertFieldL(10,field,KDateTimeFieldUid); // pos=10
		test(ret==KErrNone);
	ret=UpdateField(10,TheFieldSetOriginal);
		test(ret);
	// value before
	HBufC* miniBuf = HBufC::NewL(5); 
	CleanupStack::PushL(miniBuf);
	ret=TheFieldSetOriginal->NewFieldValueL(miniBuf,10); // pos=10
		test(ret==KErrNone);
	TPtr buf = miniBuf->Des();
	INFO_PRINTF1(_L("  Value before streaming: "));
		INFO_PRINTF1(buf);
		INFO_PRINTF1(_L("\n"));
	// test streaming
	testStoreRestore(TheFieldSetCopy,TheFieldSetOriginal);
	test(IsEqual(TheFieldSetCopy,TheFieldSetOriginal));
	// value after
	ret=TheFieldSetCopy->NewFieldValueL(miniBuf,10); // pos=10
		test(ret==KErrNone);
	buf = miniBuf->Des();
	INFO_PRINTF1(_L("  Value after streaming:  "));
		INFO_PRINTF1(buf);
		INFO_PRINTF1(_L("\n"));
	CleanupStack::PopAndDestroy(); // miniBuf
	TheFieldSetOriginal->Reset();
	TheFieldSetCopy->Reset();
	}


void CT_STREAM::TestStreamingL()
//
// Test streaming of PrintSetup info.
// Stream from one copy to another, then compare
//
	{
	// create the PrintSetups
	INFO_PRINTF1(_L("Streaming CTextFieldSet"));

	// instantiate the factory and FieldSet
	TheFactory = new(ELeave) TTestFieldFactory();
	TheFieldSetOriginal = CTextFieldSet::NewL();
	TheFieldSetOriginal->SetFieldFactory(TheFactory);
	TheFieldSetCopy = CTextFieldSet::NewL();
	TheFieldSetCopy->SetFieldFactory(TheFactory);

	// Use "original" with default settings & test stream
	test2();

	// change data in original and test stream again
	test3();

	// Stream a field set into a non-empty target
	test4();

	// Stream a field set containing an out of date field
	test5();

	// Test that copy/paste methods exist
	test6();

	// Test copy/paste methods in detail
	test7();

	// Test paste with limited target area
	test8();

	// Test paste into set with no field factory
	test9();

	// Test streaming of built-in types
	test10();

	// end
	delete TheFieldSetOriginal;
	delete TheFieldSetCopy;
	delete TheFactory;
	}


void CT_STREAM::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_STREAM::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_STREAM::CT_STREAM()
    {
    SetTestStepName(KTestStep_T_STREAM);
    }

TVerdict CT_STREAM::doTestStepL()
    {
	INFO_PRINTF1(_L("T_STREAM - Fields Persistence"));
    SetTestStepResult(EFail);

    __UHEAP_MARK;

	setupCleanup();
    
    TRAPD(error1, TestStreamingL());

	delete TheTrapCleanup;

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

    if(error1 == KErrNone)
        {
        SetTestStepResult(EPass);
        }

    return TestStepResult();
    }