/*

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

     }