diff -r 000000000000 -r a41df078684a kerneltest/f32test/fsstress/t_soak1.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/fsstress/t_soak1.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,971 @@
+// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+// f32test\fsstress\t_soak1.cpp
+// Suggestions for future improvements: The createVerifyFileX method uses local 
+// RBufs for writing and reading. By making these buffers global (at least the 
+// write buffers), the overhead of allocating and filling memory can be avoided.
+// 
+//
+
+#include <f32file.h>
+#include <e32test.h>
+#include "t_chlffs.h"
+#include "t_server.h"
+#define __TESTING_LFFS__
+
+LOCAL_D TInt gDriveNumber;
+
+const TInt KMaxNumberThreads     = 4;
+const TInt KHeapSize             = 0x600000;
+const TInt KDiskUnitThreshold    = 0x1000000; // if disk metrics are above threshold, display in MB rather than KB
+const TInt KNotificationInterval = 10 * 1000000;
+
+const TInt KMaxSizeArray         = 3;
+const TInt KMaxFilesPerDirectory = 100;
+
+struct TTestMetrics
+	{
+	TInt SizeArray[KMaxSizeArray][5];
+	TInt KSpaceRequiredForMakeAndDelete;
+	TInt KFillDiskFileSize;
+	};
+
+
+
+
+///#define SINGLE__THREAD
+
+// 256 sectors, 17 sectors+1, 3 bytes, 254 sectors+4, 100 sectors
+//  50 sectors, 113 sectors+25, 10 sectors, 103 bytes, 199 sectors+44
+// 24 sectors+166, 189 bytes, 225 sectors, 4 sectors+221, 117 sectors+40
+LOCAL_D const TTestMetrics DefMetrics =
+				{
+				{{65536,4353,3,65028,25600},	// Sizearray[0]
+				{12800,28953,2560,103,50988},	// Sizearray[1]
+				{6310,189,57600,1245,29992}},	// Sizearray[2]
+				655360,							// KSpaceRequiredForMakeAndDelete
+				65536							// KFillDiskFileSize
+				};
+
+// 16 sectors, 1 sectors+1, 3 bytes, 15 sectors+4, 6 sectors
+//  3 sectors, 7 sectors+25, 1 sector, 103 bytes, 12 sectors+44
+// 2 sectors+166, 189 bytes, 15 sectors, 4 sectors+221, 7 sectors+40
+LOCAL_D const TTestMetrics LffsMetrics = 
+				{
+				{{4096,257,3,3844,1536},		// Sizearray[0]
+				{768,1817,256,103,3116},		// Sizearray[1]
+				{678,189,3840,1245,1832}},		// Sizearray[2]
+				36864,							// KSpaceRequiredForMakeAndDelete
+				4096							// KFillDiskFileSize
+				};
+
+// 1600 sectors, 100 sectors+100, 1 sector+44, 1501 sectors+144, 600 sectors
+// 300 sectors, 709 sectors+196, 100 sectors, 40 sectors+60, 1217 sectors+48
+// 264 sectors+216, 73 sectors+212, 486 sectors+84, 715 sectors+160
+LOCAL_D const TTestMetrics FAT32Metrics =
+				{
+				{{409600,25700,300,384400,153600},		// Sizearray[0]
+				{76800,181700,25600,10300,311600},		// Sizearray[1]
+				{67800,18900,384000,124500,183200}},	// Sizearray[2]
+				3686400,								// KSpaceRequiredForMakeAndDelete
+				409600									// KFillDiskFileSize
+				};
+
+// 8 sectors, 1 sectors+1, 3 bytes, 7 sectors+4, 3 sectors
+//  1 sectors, 3 sectors+25, 1 sector, 103 bytes, 6 sectors+44
+// 1 sector+166 bytes, 189 bytes, 7 sectors, 2 sectors+221, 3 sectors+40
+
+LOCAL_D const TTestMetrics NandMetrics = 
+				{
+				{{2048,257,3,1796,768},			// Sizearray[0]
+				{256,793,256,103,1580},			// Sizearray[1]
+				{422,189,1792,833,808}},		// Sizearray[2]
+				20480,							// KSpaceRequiredForMakeAndDelete
+				2048							// KFillDiskFileSize
+				};
+
+
+
+LOCAL_D const TTestMetrics* TheMetrics = 0;
+
+
+#if defined(__WINS__)
+#define WIN32_LEAN_AND_MEAN
+#pragma warning (disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
+#pragma warning (default:4201) // warning C4201: nonstandard extension used : nameless struct/union
+#endif
+
+#if defined(_UNICODE)
+	#if !defined(UNICODE)
+		#define UNICODE
+	#endif
+#endif
+
+#ifndef SINGLE__THREAD
+	#define REUSE_THREAD
+#endif
+
+#ifdef REUSE_THREAD
+	LOCAL_D TBool gRequestEnd;
+#endif
+
+class TThreadTestInfo
+	{
+public:
+	TInt iCycles;
+	TInt iErrors;
+	TInt iSizeArrayPos;
+	TInt iErrorInfo;
+	};
+
+GLDEF_D RTest test(_L("T_SOAK1"));
+LOCAL_D TThreadTestInfo ThreadTestInfo[KMaxNumberThreads];
+LOCAL_D TBool CurrentlyFillingDisk;
+LOCAL_D TInt FillDiskCount;
+LOCAL_D TInt FillDiskCycle;
+
+LOCAL_C TInt MakeAndDeleteFilesThread(TAny* anId);
+LOCAL_C TInt FillAndEmptyDiskThread(TAny* anId);
+LOCAL_C TInt CreateVerifyFileX(const TDesC& aBaseName,TInt aSize,RFs &aFs,TInt aPattern);
+LOCAL_C TInt MakeFileName(TInt aThreadId, TInt aFileNumber, RFs & aFs, TFileName& aName, TBool aMakeDir = ETrue);
+LOCAL_C TInt AppendPath(TFileName& aPath, TInt aNumber, TInt aLevel);
+
+_LIT( KConnect, "Connect" );
+_LIT( KDelete, "Delete" );
+_LIT( KDriveToChar, "DriveToChar" );
+_LIT( KAppendPath, "AppendPath" );
+_LIT( KSetSessPath, "SetSessPath" );
+_LIT( KMdAll, "MkdirAll" );
+_LIT( KVolInfo, "VolInfo" );
+_LIT( KReplace, "Replace" );
+_LIT( KRead, "Read" );
+_LIT( KWrite, "Write" );
+_LIT( KFlush, "Flush" );
+_LIT( KDataCompare, "DataCompare" );
+_LIT( KMemory, "Memory" );
+_LIT( KFilePrefix, "FILE_" );
+
+_LIT(KPath, "?:\\SOAK_TEST\\SESSION%d\\");
+
+LOCAL_C void LogError( TInt aError, const TDesC& aAction, const TDesC& aFileName, TUint a1, TUint a2, TInt line = -1 )
+	{
+	if(line >= 0)
+		{
+		_LIT(KFmt, "TSOAK1 ERROR (line %d): %d, file [%S], %S, (0x%x, 0x%x)");
+		RDebug::Print(KFmt, line, aError, &aFileName, &aAction, a1, a2);
+		}
+	else 
+		{
+		_LIT(KFmt, "TSOAK1 ERROR: %d, file [%S], %S, (0x%x, 0x%x)");
+		RDebug::Print(KFmt, aError, &aFileName, &aAction, a1, a2);
+		}
+	}
+
+LOCAL_C TInt MakeFileName(TInt aThreadId, TInt aFileNumber, RFs & aFs, TFileName& aName, TBool aMakeDir)
+//
+// creates a file name and makes all the directory components, if required
+//
+	{
+	
+	TFileName path;
+	path.Format(KPath, aThreadId);
+	
+	TChar driveLetter;
+	TInt  r;
+	r = aFs.DriveToChar(gDriveNumber, driveLetter);
+	if (r != KErrNone)
+		{
+		LogError(r, KDriveToChar, KNullDesC, driveLetter, 0);
+		aFs.Close();
+		return(r);
+		}
+		
+	path[0] = (TText) driveLetter;
+	r = aFs.SetSessionPath(path);
+	if (r != KErrNone)
+		{
+		LogError(r, KSetSessPath, path, 0, 0);
+		aFs.Close();
+		return(r);
+		}
+		
+	// add additional directories
+	TInt fileNumber;
+	fileNumber = aFileNumber;
+	r = AppendPath(path, fileNumber, 0);
+	if(r != KErrNone)
+		{
+		LogError(r, KAppendPath, path, fileNumber, 0);
+		aFs.Close();
+		return(r);
+		}
+		
+	if(aMakeDir)
+		{
+		r = aFs.MkDirAll(path);
+		if (r != KErrNone && r != KErrAlreadyExists)
+			{
+			LogError(r, KMdAll, path, 0, 0);
+			aFs.Close();
+			return(r);
+			}
+		}
+		
+	// and finally add file name
+	path.Append(KFilePrefix);
+	path.AppendNum(aFileNumber);
+
+	aName = path;
+	return(KErrNone);
+	}
+	
+
+LOCAL_C TInt AppendPath(TFileName& aPath, TInt aNumber, TInt aLevel)
+//
+// helper function for MakeFileName()
+//
+	{
+	
+	if(aNumber > KMaxFilesPerDirectory)
+		{
+		aNumber /= KMaxFilesPerDirectory;
+		AppendPath(aPath, aNumber, aLevel + 1);
+		}
+		
+	if(aLevel)
+		{	
+		aPath.AppendNum(aNumber % KMaxFilesPerDirectory);	
+		aPath.Append('\\');	
+		}
+	
+	return(KErrNone);
+	}
+
+LOCAL_C TInt MakeAndDeleteFilesThread(TAny* anId)
+//
+// The entry point for the 'MakeAndDeleteFiles' thread.
+//
+	{
+
+	TInt thrdId=(TInt)anId;
+	TInt pattern=(ThreadTestInfo[thrdId].iCycles)%2;
+    TInt r;
+	RFs f;
+	r=f.Connect();
+	if (r!=KErrNone)
+		{
+		LogError( r, KConnect, KNullDesC, 0, 0 );
+		ThreadTestInfo[thrdId].iErrorInfo=1;
+		return(r);
+		}
+
+	TFileName fileName;
+	TInt sizeArrayPos = ThreadTestInfo[thrdId].iSizeArrayPos;
+#ifdef REUSE_THREAD
+	while(!gRequestEnd)
+		{
+#endif	
+		for(TInt i = 0; i < 5; i++)
+			{
+			// create files
+			r = MakeFileName(thrdId, i, f, fileName);
+			if(r != KErrNone)
+				{
+				ThreadTestInfo[thrdId].iErrorInfo=2;
+				f.Close();
+				return(r);
+				}
+			
+			r = CreateVerifyFileX(fileName, TheMetrics->SizeArray[sizeArrayPos][0], f, pattern);
+			if (r!=KErrNone)
+				{
+				ThreadTestInfo[thrdId].iErrorInfo=3;
+				f.Close();
+				return(r);
+				}
+			
+			// delete selected files at certain points in the cycle
+			TInt deleteFile = EFalse;
+			switch(i)
+				{
+				default:
+					// nothing to be done
+				break;
+				case 2:
+					// delete file 0
+					deleteFile = ETrue;
+					r = MakeFileName(thrdId, 0, f, fileName, EFalse);
+				break;
+				case 3:
+					// delete file 1
+					deleteFile = ETrue;
+					r = MakeFileName(thrdId, 1, f, fileName, EFalse);
+				break;
+				}
+				
+				if(deleteFile)
+					{
+					// check MakeFileName() error code
+					if(r != KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo = 4;
+						f.Close();
+						return(r);
+						}
+						
+					// and delete file
+					r = f.Delete(fileName);
+					if(r != KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo = 5;
+						f.Close();
+						return(r);
+						}
+					}
+			}
+			
+		sizeArrayPos++;
+		if(sizeArrayPos >= KMaxSizeArray)
+			{
+			sizeArrayPos = 0;
+			}
+			
+		ThreadTestInfo[thrdId].iSizeArrayPos=sizeArrayPos;
+#ifdef REUSE_THREAD
+	ThreadTestInfo[thrdId].iCycles++;
+	pattern = (ThreadTestInfo[thrdId].iCycles) % 2;
+	}
+#endif
+
+	f.Close();
+	return(KErrNone);
+	}
+
+LOCAL_C TInt FillAndEmptyDiskThread(TAny* anId)
+//
+// The entry point for the 'FillAndEmptyDisk' thread.
+//
+	{
+
+	TInt thrdId=(TInt)anId;
+	TInt pattern=(ThreadTestInfo[thrdId].iCycles)%2;
+    TInt r;
+	RFs f;
+	r=f.Connect();
+	if (r!=KErrNone)
+		{
+		LogError( r, KConnect, KNullDesC, 0, 0 );
+		ThreadTestInfo[thrdId].iErrorInfo=6;
+		return(r);
+		}
+
+	TInt i;
+#ifdef REUSE_THREAD
+	while(!gRequestEnd)
+		{
+#endif	
+		for (i=0;i<5;i++) // Create/Delete 5 files each time
+			{
+			if (CurrentlyFillingDisk)
+				{
+				TVolumeInfo v;
+				r=f.Volume(v,gDriveNumber);
+				if (r!=KErrNone)
+					{
+					ThreadTestInfo[thrdId].iErrorInfo=7;
+					LogError( r, KVolInfo, KNullDesC, gDriveNumber, 0);
+					f.Close();
+					return(r);
+					}
+				if (v.iFree<=(TheMetrics->KSpaceRequiredForMakeAndDelete+TheMetrics->KFillDiskFileSize))
+					CurrentlyFillingDisk=EFalse;
+				else
+					{
+					TFileName fileName;
+					r = MakeFileName(thrdId, FillDiskCount, f, fileName);
+					if(r != KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo = 8;
+						f.Close();
+						return(r);
+						}			
+					
+					r = CreateVerifyFileX(fileName, TheMetrics->KFillDiskFileSize, f, pattern);
+					if (r!=KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo=9;
+						f.Close();
+						return(r);
+						}
+					FillDiskCount++;
+					}
+				}
+			else
+				{
+				if (FillDiskCount<=0)
+					{
+					CurrentlyFillingDisk=ETrue;
+					FillDiskCount=0;
+					FillDiskCycle++;
+					}
+				else
+					{
+					FillDiskCount--;
+					TFileName fileName;
+					r = MakeFileName(thrdId, FillDiskCount, f, fileName, EFalse);
+					if(r != KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo = 10;
+						f.Close();
+						return(r);
+						}
+					
+					r = f.Delete(fileName);				
+					if (r!=KErrNone)
+						{
+						ThreadTestInfo[thrdId].iErrorInfo=11;
+						LogError(r, KDelete, fileName,FillDiskCount, 0);
+						f.Close();
+						return(r);
+						}
+					}
+				}
+			}
+#ifdef REUSE_THREAD
+		ThreadTestInfo[thrdId].iCycles++;
+		pattern = (ThreadTestInfo[thrdId].iCycles) % 2;
+		}			
+#endif
+
+	f.Close();
+	return(KErrNone);
+	}
+
+const TInt KCreateFileBufSize = 0x80000; 
+LOCAL_C TInt CreateVerifyFileX(const TDesC& aFileName, TInt aSize, RFs& aFs, TInt aPattern)
+//
+// Create and verify a file.
+//
+	{
+	// Note, the directory structure is provided by MakeFileName(). Hence it 
+	// is assumed at this point that the path to the file exists already.
+	RFile file;
+	TInt r;
+	r = file.Replace(aFs, aFileName, EFileWrite);
+	if (r!=KErrNone)
+		{
+		LogError( r, KReplace, aFileName, EFileWrite, 0 );
+		return(r);
+		}
+
+	// Grow it to the specified size by writing a pattern buffer to it
+	// Alternate the pattern buffer each time
+	RBuf8 wBuf;
+	r = wBuf.CreateMax(KCreateFileBufSize);
+	if(r != KErrNone)
+		{
+		LogError(r, KMemory, aFileName, 0, 0, __LINE__);
+		wBuf.Close();
+		file.Close();
+		return(r);
+		}
+		
+	TInt i;
+	
+	if (aPattern)
+		{
+		// ascending pattern
+		for (i = 0; i < KCreateFileBufSize; i++)
+			{			
+			wBuf[i] = (TUint8) i;			
+			}
+		}
+	else
+		{
+		// descending pattern
+		for (i = 0; i < KCreateFileBufSize; i++)
+			{
+			wBuf[i] = (TUint8) ((KCreateFileBufSize - 1) - i);
+			}
+		}
+
+
+	TInt pos;
+	TInt chunkSize;
+	TInt sectorCount = 0;
+	
+	for (pos = 0; pos < aSize; pos += chunkSize)
+		{
+		wBuf[0]=(TUint8)i;	// Insert sector count
+		chunkSize = Min((aSize-pos), KCreateFileBufSize);
+		r = file.Write(pos, wBuf, chunkSize);
+		if (r != KErrNone)
+			{
+			LogError(r, KWrite, aFileName, pos, chunkSize, __LINE__);
+			file.Close();
+			wBuf.Close();
+			return(r);
+			}
+			
+		sectorCount++;
+		}
+
+	// Flush it
+	r=file.Flush();
+	if (r!=KErrNone)
+		{
+		LogError( r, KFlush, aFileName, 0, 0, __LINE__);
+		file.Close();
+		wBuf.Close();
+		return(r);
+		}
+
+//	Test still works if this is commented out just doesn't verify
+	// Read back and verify it
+	RBuf8 rBuf;
+	r = rBuf.CreateMax(KCreateFileBufSize);
+	if(r != KErrNone)
+		{
+		LogError( r, KMemory, aFileName, 0, 0, __LINE__);
+		file.Close();
+		wBuf.Close();
+		rBuf.Close();
+		return(KErrGeneral);
+		}
+	
+	
+	for (pos = 0;pos < aSize; pos += chunkSize)
+		{
+		chunkSize = Min((aSize-pos), KCreateFileBufSize);
+		r = file.Read(pos, rBuf, chunkSize);
+		if (r != KErrNone)
+			{
+			LogError(r, KRead, aFileName, pos, 0, __LINE__);
+			file.Close();
+			wBuf.Close();
+			rBuf.Close();
+			return(r);
+			}
+			
+		wBuf[0] = (TUint8) i; // Insert sector count
+		wBuf.SetLength(chunkSize);
+		r = rBuf.Compare(wBuf);
+		if (r != 0)
+			{
+			LogError(r, KDataCompare, aFileName, 0, 0, __LINE__);
+			file.Close();
+			wBuf.Close();
+			rBuf.Close();
+			return(KErrGeneral);
+			}
+		}
+//
+
+	file.Close();
+	wBuf.Close();
+	rBuf.Close();
+	return(KErrNone);
+	}
+	
+
+#ifdef SINGLE__THREAD
+LOCAL_C void DoTests()
+//
+//  single thread
+//
+    {
+
+	TInt r=KErrNone;
+	test.Next(_L("Start continuous file Write/Read/Verify operation"));
+	RThread t[KMaxNumberThreads];
+	TRequestStatus tStat[KMaxNumberThreads];
+
+	TInt i=0;
+
+	TName threadName;
+	TRequestStatus kStat=KRequestPending;
+	test.Console()->Read(kStat);
+	ThreadTestInfo[i].iCycles=0;
+	ThreadTestInfo[i].iErrors=0;
+	ThreadTestInfo[i].iSizeArrayPos=(i%KMaxSizeArray);
+	ThreadTestInfo[i].iErrorInfo=0;
+	if (i<(KMaxNumberThreads-1))
+		{
+		threadName.Format(_L("MakeAndDeleteFiles%d"),i);
+    	r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+		}
+	else
+		{
+		// Last thread fills/empties disk
+		threadName.Format(_L("FillAndEmptyDisk%d"),i);
+    	r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+		}
+	if (r!=KErrNone)
+		test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);
+	test(r==KErrNone);
+	t[i].Logon(tStat[i]);
+	t[i].Resume();
+	CurrentlyFillingDisk=ETrue;
+	FillDiskCount=0;
+
+    TInt totalTime=0;
+    TTime startTime;
+    TTime time;
+    startTime.UniversalTime();
+
+	TInt ypos=test.Console()->WhereY();
+	FOREVER
+		{
+		User::WaitForAnyRequest();
+		if (kStat!=KRequestPending)
+			{
+    		t[i].LogonCancel(tStat[i]);
+			User::WaitForRequest(tStat[i]);
+			break;
+			}
+		else
+			{
+			TBool threadFinished=EFalse;
+			if (tStat[i]!=KRequestPending && !threadFinished)
+				{
+				t[i].Close();
+				(ThreadTestInfo[i].iCycles)++;
+				if (tStat[i]!=KErrNone)
+					(ThreadTestInfo[i].iErrors)++;
+				threadFinished=ETrue;
+
+				// Launch another thread
+				TInt threadNameId=((ThreadTestInfo[i].iCycles)%2)?(i+KMaxNumberThreads):i; // Alternate thread name
+				threadName.Format(_L("FillAndEmptyDisk%d"),threadNameId);
+   				r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+				if (r!=KErrNone)
+					test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);
+    			test(r==KErrNone);
+    			t[i].Logon(tStat[i]);
+				t[i].Resume();
+				}
+				
+			test.Console()->SetPos(0,(ypos+i));
+			test.Printf(_L("Thread(%d): % 4d errors in % 4d cycles (%d)\r\n"),i,ThreadTestInfo[i].iErrors,ThreadTestInfo[i].iCycles,ThreadTestInfo[i].iErrorInfo);
+			if (!threadFinished)
+				{
+				test.Printf(_L("Semaphore death"));
+				break;
+				}
+			TVolumeInfo v;
+			r=TheFs.Volume(v,gDriveNumber);
+			test(r==KErrNone);
+			test.Console()->SetPos(0,(ypos+KMaxNumberThreads));
+			test.Printf(_L("Free space on disk: %u K(of %u K)\r\n"),(v.iFree/1024).Low(),(v.iSize/1024).Low());
+
+            TTimeIntervalSeconds timeTaken;
+            time.UniversalTime();
+            r=time.SecondsFrom(startTime,timeTaken);
+            test(r==KErrNone);
+            totalTime=timeTaken.Int();
+
+            TInt seconds = totalTime % 60;
+            TInt minutes = (totalTime / 60) % 60;
+            TInt hours   = (totalTime / 3600) % 24;
+            TInt days    = totalTime / (60 * 60 * 24);
+            test.Printf(_L("Elapsed Time: %d d %02d:%02d:%02d\r\n"), days, hours, minutes, seconds);
+			}
+		}
+    }
+
+#else 
+
+LOCAL_C void DoTests()
+//
+//  multiple threads
+//
+    {
+
+	TInt r=KErrNone;
+	test.Next(_L("Start continuous file Write/Read/Verify operation"));
+	RThread t[KMaxNumberThreads];
+	TRequestStatus tStat[KMaxNumberThreads];
+
+	TInt i=0;
+
+	TName threadName;
+	TRequestStatus kStat=KRequestPending;
+	test.Console()->Read(kStat);
+	for (i=0;i<KMaxNumberThreads;i++)
+		{
+		ThreadTestInfo[i].iCycles=0;
+		ThreadTestInfo[i].iErrors=0;
+		ThreadTestInfo[i].iSizeArrayPos=(i%KMaxSizeArray);
+		ThreadTestInfo[i].iErrorInfo=0;
+		if (i<(KMaxNumberThreads-1))
+			{
+			threadName.Format(_L("MakeAndDeleteFiles%d"),i);
+	    	r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+			}
+		else
+			{
+			// Last thread fills/empties disk
+			threadName.Format(_L("FillAndEmptyDisk%d"),i);
+	    	r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+			}
+		if (r!=KErrNone)
+   			test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);
+	    test(r==KErrNone);
+	    t[i].Logon(tStat[i]);
+		t[i].Resume();
+		}
+	CurrentlyFillingDisk=ETrue;
+	FillDiskCount=0;
+
+    TInt totalTime = 0;
+    TTime cycleTime;
+    TTime startTime;
+    TTime time;
+    startTime.UniversalTime();
+    cycleTime.UniversalTime();
+    
+	TVolumeInfo v;
+	r=TheFs.Volume(v,gDriveNumber);
+	test(r==KErrNone);
+//	TInt initialFreeSpace = I64LOW(v.iFree / 1024);
+
+#ifdef __LIMIT_EXECUTION_TIME__
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+	timer.After(reqStat,60000000); // After 60 secs
+#endif
+
+#ifdef REUSE_THREAD
+	RTimer displayTimer;
+	displayTimer.CreateLocal();
+	TRequestStatus displayStat;
+	displayTimer.After(displayStat, KNotificationInterval); // after 10 secs
+#endif
+
+	TInt ypos=test.Console()->WhereY();
+	FOREVER
+		{
+		User::WaitForAnyRequest();
+		if (kStat!=KRequestPending)
+			{
+			// user requested to end - let threads die
+#ifdef REUSE_THREAD				
+			gRequestEnd = ETrue;
+#endif			
+			for (i=0;i<KMaxNumberThreads;i++)
+				{
+				User::WaitForRequest(tStat[i]);
+				}
+			break;
+			}
+#ifdef __LIMIT_EXECUTION_TIME__
+		else if (reqStat != KRequestPending)
+			{
+			// max execution exceeded - wait for threads to die
+			TInt totalCycles = 0;
+			for (i=0;i<KMaxNumberThreads;i++)
+				{
+				totalCycles+= ThreadTestInfo[i].iCycles;
+				}
+			test.Printf(_L("Total cycles = %d\r\n"), totalCycles);
+			test.Printf(_L("Waiting for thread death...\r\n"));
+			for (i=0;i<KMaxNumberThreads;i++)
+				{
+				User::WaitForRequest(tStat[i]);
+				}
+			break;
+			}
+#endif
+		else
+			{
+			// other notification
+			TBool threadFinished=EFalse;
+			for (i=0;i<KMaxNumberThreads;i++)
+				{
+				if (tStat[i]!=KRequestPending && !threadFinished)
+					{
+					t[i].Close();
+					(ThreadTestInfo[i].iCycles)++;
+					if (tStat[i]!=KErrNone)
+						(ThreadTestInfo[i].iErrors)++;
+					threadFinished=ETrue;
+
+					// Launch another thread
+					TInt threadNameId=((ThreadTestInfo[i].iCycles)%2)?(i+KMaxNumberThreads):i; // Alternate thread name
+					if (i<(KMaxNumberThreads-1))
+						{
+						threadName.Format(_L("MakeAndDeleteFiles%d"),threadNameId);
+	    				r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+						}
+					else
+						{
+						// Last thread fills/empties disk
+						threadName.Format(_L("FillAndEmptyDisk%d"),threadNameId);
+	    				r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);
+						}
+					if (r!=KErrNone)
+   						test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);
+	    			test(r==KErrNone);
+	    			t[i].Logon(tStat[i]);
+					t[i].Resume();
+					}
+				test.Console()->SetPos(0,(ypos+i));
+   				test.Printf(_L("Thread(%d): % 4d errors in % 4d cycles (%d)\r\n"),i,ThreadTestInfo[i].iErrors,ThreadTestInfo[i].iCycles,ThreadTestInfo[i].iErrorInfo);
+				}
+				
+#ifdef REUSE_THREAD
+			if(displayStat != KRequestPending)
+				{
+				// re-request notification
+				displayTimer.After(displayStat, KNotificationInterval);
+				}
+			else if (!threadFinished)
+				{
+				test.Printf(_L("Semaphore death"));
+				break;
+				}
+#else 
+			if (!threadFinished)
+				{
+				test.Printf(_L("Semaphore death"));
+				break;
+				}
+#endif					
+				
+			r=TheFs.Volume(v,gDriveNumber);
+			test(r==KErrNone);
+			test.Console()->SetPos(0,(ypos+KMaxNumberThreads));
+			
+			TInt  freeSpace;
+			TInt8 freeSpaceUnit;
+			TInt  totalSpace;
+			TInt8 totalSpaceUnit;
+			
+			// switch t
+			if(v.iFree > KDiskUnitThreshold)
+				{
+				// display in MB
+				freeSpace = I64LOW(v.iFree / (1024 * 1024));
+				freeSpaceUnit = 'M';
+				}
+			else
+				{
+				// display in KB
+				freeSpace = I64LOW(v.iFree/1024);
+				freeSpaceUnit = 'K';
+				}
+			
+			if(v.iSize > KDiskUnitThreshold)
+				{
+				// display in MB
+				totalSpace = I64LOW(v.iSize / (1024 * 1024));
+				totalSpaceUnit = 'M';
+				}
+			else
+				{
+				// display in KB
+				totalSpace = I64LOW(v.iSize/1024);
+				totalSpaceUnit = 'K';
+				}
+			
+			test.Printf(_L("Free space on disk: %u %cB (of %u %cB)\r\n"), 
+						freeSpace, freeSpaceUnit, totalSpace, totalSpaceUnit);
+
+            TTimeIntervalSeconds timeTaken;
+            time.UniversalTime();            
+            r=time.SecondsFrom(startTime,timeTaken);
+            test(r==KErrNone);
+            totalTime=timeTaken.Int();
+
+            TInt seconds = totalTime % 60;
+            TInt minutes = (totalTime / 60) % 60;
+            TInt hours   = (totalTime / 3600) % 24;
+            TInt days    = totalTime / (60 * 60 * 24);
+            test.Printf(_L("Elapsed Time (%d): %d d %02d:%02d:%02d\r\n"), FillDiskCycle, days, hours, minutes, seconds);
+            
+            if(CurrentlyFillingDisk)
+            	{
+            	// work out ETA to full disk
+	            r = time.SecondsFrom(cycleTime, timeTaken);
+    	        if((r == KErrNone) && (v.iSize > v.iFree))
+    	        	{
+		            	totalTime = (TInt) ((v.iFree/1024 * (TInt64) timeTaken.Int()) / (v.iSize/1024 - v.iFree/1024));
+		    	        seconds = totalTime % 60;
+    		    	    minutes = (totalTime / 60) % 60;
+        		    	hours   = (totalTime / 3600) % 24;
+	            		days    = totalTime / (60 * 60 * 24);
+            	
+    	        		test.Printf(_L("ETA to full disk: %d d %02d:%02d:%02d\r\n"), days, hours, minutes, seconds);
+        	    	}
+            	}
+            else 
+            	{
+            	// currently emptying disk, update time metrics
+            	cycleTime.UniversalTime();
+            	}            	
+           	
+			}
+						
+			test.Printf(_L("\n"));
+		}
+    }
+#endif
+
+
+GLDEF_C void CallTestsL()
+//
+// Call all tests
+//
+    {
+	TInt r = TheFs.CharToDrive( gSessionPath[0], gDriveNumber );
+	test( KErrNone == r );
+	
+	// select appropriate metrics table
+	if(IsFileSystemFAT32(TheFs, gDriveNumber)) 
+		{
+		TheMetrics = &FAT32Metrics;
+		RDebug::Printf("Using FAT32 metrics\r\n");
+		}
+	else if(IsTestingLFFS())
+		{
+		TheMetrics = &LffsMetrics;
+		RDebug::Printf("Using LFFS metrics\r\n");
+		}
+	else
+		{
+		TDriveInfo driveInfo;
+		r=TheFs.Drive(driveInfo, gDriveNumber);
+		test(r==KErrNone);
+		
+		if((driveInfo.iType==EMediaNANDFlash) && !(driveInfo.iMediaAtt & KMediaAttWriteProtected))
+			{
+			TheMetrics = &NandMetrics;
+			RDebug::Printf("Using NAND metrics\r\n");
+			}
+		else 
+			{
+			TheMetrics = &DefMetrics;
+			RDebug::Printf("Using default metrics\r\n");
+			}
+		}
+		
+	FillDiskCycle = 1;
+#ifdef REUSE_THREAD
+	gRequestEnd = EFalse;
+#endif
+	DoTests();
+
+    }
+