diff -r 000000000000 -r 08ec8eefde2f persistentstorage/store/TSTOR/T_BMStreams.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/store/TSTOR/T_BMStreams.inl	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,296 @@
+// Copyright (c) 2008-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:
+// This is the file name, extension and path specification for the file store 
+// and should not be used as is
+// 
+//
+
+_LIT(KStreamsName, "Z:\\STOR-TST\\BMStreams.dat");
+extern TFileName TheStreamsFilePath;
+
+// Construct CCompound object and externalize it to a single stream
+LOCAL_C void doExternalizeL(const TDesC& aName);
+
+// Internalize CCompound object from the stream
+LOCAL_C void doInternalizeL(const TDesC& aName);
+
+#define STREAMRUNSIZE 1000
+// Declare a class used by the example
+class CStreamA
+	{
+public :
+	void ExternalizeL(RWriteStream& aStream) const;
+	void InternalizeL(RReadStream& aStream);
+public :
+	TBuf<32> iBufferA;
+	TInt     iXA;
+	TUint    iYA;
+	};
+
+class TStream
+	{
+public :
+	void ExternalizeL(RWriteStream& aStream) const;
+	void InternalizeL(RReadStream& aStream);
+public :
+	TReal iZC;
+	};
+	
+class CCompound : public CBase
+	{
+public :
+	~CCompound();
+	static		CCompound* NewLC();
+	static		CCompound* NewLC(CStreamStore& aStore,TStreamId anId);
+	static		CCompound* NewL(CStreamStore& aStore,TStreamId anId);
+	TStreamId	StoreL(CStreamStore& store);
+	void		RestoreL(CStreamStore& aStore,TStreamId anId);
+	void		InternalizeL(RReadStream& aStream);
+	void		ExternalizeL(RWriteStream& aStream) const;
+private:
+    void		ConstructL();
+	void		ConstructL(CStreamStore& aStore,TStreamId anId);
+public :
+	CStreamA* iCa;
+	TStream  iTc;
+	CArrayFixFlat<TElement>* iArray;
+	};
+
+
+/**
+@SYMTestCaseID          SYSLIB-STORE-PT-1369
+@SYMTestCaseDesc	CR MRLM-6A9DF7. Tests the impact of RFileBuf cache size on CDirectFileStore performance. RFileBuf cache size must be set at a build time in EStor_Template.mmh file, DEFAULT_FILE_BUF_SIZE macro definition.
+@SYMTestPriority 	High
+@SYMTestActions  	The test creates a set of test objects, externalizes them STREAMRUNSIZE times and prints the execution time. Then internalizes them STREAMRUNSIZE times and prints the execution time.
+STREAMRUNSIZE is a constant, defined in the source file.
+@SYMTestExpectedResults Test must show a performance improvement
+@SYMPREQ                PREQ1132
+@SYMREQ			REQ4883
+*/
+LOCAL_C void doStreamingL()
+    {
+    TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	
+	TParse streamsName;
+	streamsName.Set(drive.Name(), &KStreamsName, NULL);
+	TheStreamsFilePath.Copy(streamsName.FullName());
+	
+	// make sure directory exists
+	TheFs.MkDirAll(streamsName.DriveAndPath());
+	TTime start;
+	start.HomeTime();
+	for(int i=0; i<STREAMRUNSIZE;i++)
+		{
+		doExternalizeL(TheStreamsFilePath);	
+		}
+	TTime end;
+	end.HomeTime();
+	TTimeIntervalMicroSeconds us = end.MicroSecondsFrom(start);
+	TheTest.Printf(_L("CDirectFileStore, externalise %d streams. Time=%ld ms\r\n"), STREAMRUNSIZE, us.Int64() / 1000);
+
+	start.HomeTime();
+	for(int j=0; j<STREAMRUNSIZE;j++)
+		{
+		doInternalizeL(TheStreamsFilePath);
+		}
+	end.HomeTime();
+	us = end.MicroSecondsFrom(start);
+	TheTest.Printf(_L("CDirectFileStore, internalise %d streams. Time=%ld ms\r\n"), STREAMRUNSIZE, us.Int64() / 1000);
+	}
+
+LOCAL_C void doExternalizeL(const TDesC& aName)
+	{
+	// construct file store object - the file to contain the store
+	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs,aName,EFileWrite);
+
+	// Must say what kind of file store
+    store->SetTypeL(KDirectFileStoreLayoutUid);
+
+	// Construct an object of type CCompound and prepare some data into it
+	CCompound* thecompound = CCompound::NewLC();
+
+	_LIT(KTxtClassAText,"CStreamA text");
+
+	thecompound->iCa->iBufferA = KTxtClassAText;
+	thecompound->iCa->iXA      = -1;
+	thecompound->iCa->iYA      = 2;
+	thecompound->iTc.iZC       = 3.456;
+	
+	TElement theElement;
+	_LIT(KFormatTxt,"BenchMarkingTheStream%4u");
+	TBuf<256> str(KFormatTxt);
+		
+	for (TInt index = 0; index < STREAMRUNSIZE; index++)
+		{
+		theElement.iData.Format(KFormatTxt,index);
+		thecompound->iArray->AppendL(theElement);
+		}
+					
+	// Store the compound object to a single stream and save the stream id as the root id
+	TStreamId  id = thecompound->StoreL(*store);
+
+	// Set the stream id as the root
+	store->SetRootL(id);
+
+	// Commit changes to the store
+	store->CommitL();
+									// thecompound
+	CleanupStack::PopAndDestroy(2); // store
+	}
+
+LOCAL_C void doInternalizeL(const TDesC& aName)
+	{
+	//Create file store object - specifying the file containing the store.
+	CFileStore* store = CDirectFileStore::OpenLC(TheFs,aName,EFileRead);
+	
+	// Construct a CCompound object from the root stream created earlier.
+	CCompound* thecompound = CCompound::NewL(*store,store->Root());
+	
+	// destroy the store object (this also closes the file containing the store) 
+	CleanupStack::PopAndDestroy();
+	// Now destroy the CCompound object
+	delete thecompound;
+	}
+
+//***************************************************************
+
+// The CCompound destructor
+CCompound::~CCompound()
+	{
+	delete iCa;
+	delete iArray;
+	}
+
+CCompound* CCompound::NewLC()
+	{
+	CCompound* self=new (ELeave) CCompound;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CCompound::ConstructL()
+	{
+	iCa = new (ELeave) CStreamA;
+	iArray = new (ELeave) CArrayFixFlat<TElement>(10);
+	}
+
+// Construct a new CCompound object from the input stream.
+CCompound* CCompound::NewL(CStreamStore& aStore,TStreamId anId)
+	{
+	CCompound* self=CCompound::NewLC(aStore,anId);
+	CleanupStack::Pop();
+	return self;
+	}
+
+// Construct CCompound object from the root stream of the store
+CCompound* CCompound::NewLC(CStreamStore& aStore,TStreamId anId)
+	{
+	CCompound* self=new (ELeave) CCompound;
+	CleanupStack::PushL(self);
+	self->ConstructL(aStore,anId);
+	return self;
+	}
+
+void CCompound::ConstructL(CStreamStore& aStore,TStreamId anId)
+	{
+	iCa = new (ELeave) CStreamA;
+	// Restore here at construction
+	RestoreL(aStore,anId);
+	}
+
+void CCompound::RestoreL(CStreamStore& aStore,TStreamId anId)
+	{
+	RStoreReadStream instream;
+	instream.OpenLC(aStore,anId);
+	InternalizeL(instream);
+	// Cleanup the stream object
+	CleanupStack::PopAndDestroy();			
+	}
+
+// Read the components and data members of the CCompound object from stream
+void CCompound::InternalizeL(RReadStream& aStream)
+	{
+	aStream >> *iCa;
+	aStream >> iTc;
+	
+	TElement theElement;
+	iArray = new (ELeave) CArrayFixFlat<TElement>(STREAMRUNSIZE);
+//	iArray->Count();
+//	iArray->Reset();
+	for (TInt index = 0; index < STREAMRUNSIZE ; index++)
+		{
+		aStream.ReadL(theElement.iData, 25);
+		iArray->AppendL(theElement);
+		}
+	}
+
+TStreamId CCompound::StoreL(CStreamStore& aStore)
+	{
+	RStoreWriteStream outstream;
+	TStreamId id = outstream.CreateLC(aStore);
+	// Stream out this CCompound object
+	ExternalizeL(outstream);
+	// Commit changes to the stream
+	outstream.CommitL();
+	// Cleanup the stream object.
+	CleanupStack::PopAndDestroy();
+	return id;
+	}
+
+// Write the components and data members of the CCompound object to stream
+void CCompound::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << *iCa;
+	aStream << iTc;
+	
+	TElement theElement;
+	TInt count = iArray->Count();
+	for (TInt index = 0; index < count; index++)
+		{
+		theElement =((*iArray)[index]);
+		aStream.WriteL(theElement.iData, 25);
+		}
+	}
+
+//***************************************************************
+
+// Read the data members of the CStreamA  object from the stream.
+void CStreamA::InternalizeL(RReadStream& aStream)
+	{
+	aStream >> iBufferA;
+  	iXA = aStream.ReadInt32L();
+	iYA = aStream.ReadUint32L();
+	}  
+// Write the data members of the CStreamA object to the stream
+void CStreamA::ExternalizeL(RWriteStream& aStream)const
+	{
+	aStream << iBufferA;
+	aStream.WriteInt32L(iXA);
+	aStream.WriteUint32L(iYA);
+	}  
+
+//***************************************************************
+
+// Write the data member(s) of the TStream object to the stream
+void TStream::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream.WriteReal64L(iZC);
+	}  
+
+// Read the data member(s) of the TStream object from the stream.
+void TStream::InternalizeL(RReadStream& aStream)
+	{
+	iZC = aStream.ReadReal64L();
+	}
+