diff -r 000000000000 -r a41df078684a kerneltest/f32test/bench/t_fsrdel.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/bench/t_fsrdel.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1861 @@
+// Copyright (c) 2006-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\bench\t_fsrdel.cpp
+// 
+//
+
+
+#include <f32file.h>
+#include <e32test.h>
+#include "t_benchmain.h"
+
+GLDEF_D RTest test(_L("File Server Benchmarks, deletion of a massive amount of files"));
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      PBASE-T_FSRDEL-0272
+//! @SYMTestType        CIT
+//! @SYMPREQ            PREQ000
+//! @SYMTestCaseDesc    This test case is measuring performance of the FAT implementation.  
+//! @SYMTestActions     0.  Expects the files to exist in order to successful execution
+//!						1.	Time the deletion of a file from each directory with RFs::Delete
+//!						2.	Time the deletion of a file from each directory with CFileMan::Delete
+//!						3.	Time the deletion of all the files from each directory 
+//!							with RFs::Delete
+//!						4.	Time the deletion of all the files from each directory with 
+//!							CFileMan::Delete (wildcard F*.*)
+//!						5.	Time the deletion of a file from each directory with RFs::Delete 
+//!							with two clients accessing the directory
+//!						6.	Time the deletion of a file from each directory with CFileMan::Delete 
+//!							with two clients accessing the directory
+//!						7.	Time the deletion of all the files from each directory with RFs::Delete 
+//!							with two clients accessing the directory
+//!						8.	Time the deletion of all the files from each directory with 
+//!							CFileMan::Delete with two clients accessing the directory (wildcard F*.*)
+//!						9.	Time the deletion of a file from each directory with RFs::Delete 
+//!							with two clients accessing different directories 
+//!						10.	Time the deletion of a file from each directory with CFileMan::Delete 
+//!							with two clients accessing different directories 
+//!						11.	Time the deletion of all the files from each directory with RFs::Delete 
+//!							with two clients accessing different directories
+//!						12.	Time the deletion of all the files from each directory with 
+//!							CFileMan::Delete with two clients accessing different directories (wildcard F*.*)
+//! @SYMTestExpectedResults Finishes if the system behaves as expected, panics otherwise
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+
+LOCAL_D RSemaphore client,write_screen;
+LOCAL_D const TInt KHeapSize=0x4000;
+LOCAL_D TBuf8<4096> buf;
+LOCAL_D TDriveList gDriveList;
+
+// Concurrent thread varibles
+RThread gSpeedy;
+RThread gSpeedyII;
+TInt gT1;
+TInt gT2;
+LOCAL_D TFileName gDelEntryDir;
+LOCAL_D TFileName gDelEntryDir2;
+LOCAL_D TInt ThreadCount=0;
+TBool gWriting = EFalse;
+
+TBool gKillMe=EFalse; 
+
+_LIT(KDeleteMe,"delete%d.me");
+_LIT(KDeleteMe2,"blabla%d.rhd");
+
+
+/** Send content through the RDebug for trgtest 
+	not to hung, when the test is not writing
+
+*/
+LOCAL_C TInt noise(TAny* )
+{
+	FOREVER
+	{	
+		User::After(2147483647); // max value, 35 minutes, 47 seconds
+		if(!gWriting)
+			RDebug::Print(_L("."));
+	}
+}
+
+/** Create background noise by deleting/creating file in gDelEntryDir2 directory
+
+*/
+LOCAL_C TInt DeleteEntryAccess2(TAny* )
+	{
+	RFs fs;
+	TInt r = 0;
+	TBuf<100> dirfile;
+	TBuf<50> filename;
+	RFile file;
+	RTest test(_L("test 2")); 
+
+	// Not checking error state until main thread has been signalled, to avoid deadlock
+	fs.Connect();
+	r = fs.SetSessionPath(gSessionPath);
+	
+	filename.Format(KDeleteMe2,gT2);
+	
+	dirfile = gDelEntryDir2;
+	dirfile.Append(filename);
+	
+	client.Signal();
+	FailIfError(r);
+	
+	FOREVER
+		{
+			if(!gKillMe)
+				{
+				r = file.Create(fs, dirfile, EFileShareAny|EFileWrite);
+				if(r == KErrAlreadyExists) 
+					r = file.Open(fs, dirfile, EFileShareAny|EFileWrite);
+				file.Close();
+				FailIfError(r);
+				
+				r = fs.Delete(dirfile);
+				if((r != KErrNone) && (r != KErrInUse)) 
+					FailIfError(r);
+				}
+		}
+	}
+
+/** Create background noise by deleting/creating file in gDelEntryDir directory
+
+*/
+LOCAL_C TInt DeleteEntryAccess(TAny*)
+	{
+	RFs fs2;
+	TInt r = 0;
+	TBuf<100> dirfile;
+	TBuf<50> filename;
+	RFile file2;
+	RTest test(_L("test 2")); 
+
+	// Not checking error state until main thread has been signalled, to avoid deadlock
+	fs2.Connect();
+	r = fs2.SetSessionPath(gSessionPath);
+	
+	filename.Format(KDeleteMe,gT1);
+	
+	dirfile = gDelEntryDir;
+	dirfile.Append(filename);
+	
+	client.Signal();
+	FailIfError(r);
+	
+	FOREVER
+		{
+			if(!gKillMe)
+				{
+				r = file2.Create(fs2, dirfile, EFileShareAny|EFileWrite);
+				if(r == KErrAlreadyExists) 
+					r = file2.Open(fs2, dirfile, EFileShareAny|EFileWrite);
+				file2.Close();
+				FailIfError(r);
+				r = fs2.Delete(dirfile);
+				if((r != KErrNone) && (r != KErrInUse)) 
+					FailIfError(r);
+				}
+		}
+	}
+
+/**  Starts a concurrent client session in different directories
+
+*/
+LOCAL_C void DoTest(TThreadFunction aFunction)
+	{
+	gKillMe = EFalse;
+
+	TBuf<20> buffer = _L("Speedy");
+	buffer.AppendNum(ThreadCount++);
+	gT1 = ThreadCount;
+	TInt r = gSpeedy.Create(buffer, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	FailIfError(r);
+
+	buffer = _L("Speedy");
+	buffer.AppendNum(ThreadCount++);
+	gT2=ThreadCount;
+	r = gSpeedyII.Create(buffer, DeleteEntryAccess2, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	FailIfError(r);
+
+ 	gSpeedy.SetPriority(EPriorityLess);
+    gSpeedyII.SetPriority(EPriorityLess);
+	
+	gSpeedy.Resume();
+	gSpeedyII.Resume();
+	
+	client.Wait();
+	client.Wait();
+	}
+		
+/**   Kills the concurrent sessions
+
+*/
+LOCAL_C void DoTestKill()
+	{
+	gKillMe = ETrue;
+	User::After(10000000);
+	
+	gSpeedy.Kill(KErrNone);
+	gSpeedy.Close();	
+	
+	gSpeedyII.Kill(KErrNone);
+	gSpeedyII.Close();	
+	}
+
+/**  Creates again the last.txt file in each directory that is being used
+
+*/
+LOCAL_C void ReCreateLast() 
+	{
+	TInt i = 1, r = 0;
+	RFile file;
+	TBuf16<50> dirtemp;
+	
+	TBuf16<50> path;
+	TBuf8<1024> dummy(1024);
+	
+	
+	while(i <= gTypes) 
+		{
+		path = gSessionPath;
+		dirtemp.Format(KDirMultipleName, i, 100);
+		path.Append(dirtemp);
+		path.Append(KCommonFile);
+		r = file.Create(TheFs, path, EFileShareAny|EFileWrite);
+		if(r == KErrAlreadyExists) 
+			{
+			r = file.Open(TheFs, path, EFileShareAny|EFileWrite);
+			FailIfError(r);
+			}
+		r = file.Write(dummy);
+		FailIfError(r);
+		file.Close();
+		i++;
+		}
+
+	if(gFilesLimit >= 1000) 
+		{
+		i = 1;
+		while(i <= gTypes) 
+			{
+			path = gSessionPath;
+			dirtemp.Format(KDirMultipleName, i, 1000);
+			path.Append(dirtemp);
+			path.Append(KCommonFile);
+			r = file.Create(TheFs, path, EFileShareAny|EFileWrite);
+			if(r == KErrAlreadyExists) 
+				{
+				r = file.Open(TheFs, path, EFileShareAny|EFileWrite);
+				FailIfError(r);
+				}
+			r = file.Write(dummy);
+			FailIfError(r);
+			file.Close();
+			i++;
+			}
+		}
+	
+	if(gFilesLimit >= 5000) 
+		{
+		i = 1;
+		while(i <= gTypes) 
+			{
+			path = gSessionPath;
+			dirtemp.Format(KDirMultipleName, i, 5000);
+			path.Append(dirtemp);
+			path.Append(KCommonFile);
+			r = file.Create(TheFs, path, EFileShareAny|EFileWrite);
+			if(r == KErrAlreadyExists) 
+				{
+				r = file.Open(TheFs, path, EFileShareAny|EFileWrite);
+				FailIfError(r);
+				}
+			r = file.Write(dummy);
+			FailIfError(r);
+			file.Close();
+			i++;
+			}
+		}
+	if(gFilesLimit >= 10000) 
+		{
+		i = 1;
+		while(i <= gTypes) 
+			{
+			path = gSessionPath;
+			dirtemp.Format(KDirMultipleName, i, 10000);
+			path.Append(dirtemp);
+			path.Append(KCommonFile);
+			r = file.Create(TheFs, path, EFileShareAny|EFileWrite);
+			if(r ==KErrAlreadyExists) 
+				{
+				r = file.Open(TheFs, path, EFileShareAny|EFileWrite);
+				FailIfError(r);
+				}
+			r = file.Write(dummy);
+			FailIfError(r);
+			file.Close();
+			i++;
+			}
+		}
+	}
+
+/**  Deletes all files in a given directory one by one
+
+	@param aN 		Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C TInt DelAllFiles1(TInt aN, TInt aStep)
+	{
+	TInt i = 0, r = 0;
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	
+	TBuf16<50> path;
+	TBuf16<50> buffer(50); 	
+
+	_LIT(KMsg, "This file caused a problem: %S\n");
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;
+	
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			directory = gSessionPath;
+			dirtemp.Format(KDirMultipleName, 1, aN);
+			directory.Append(dirtemp);
+		
+			i = 0;
+			startTime.HomeTime();
+			while(i < aN) 
+				{
+				FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				if(r != KErrNone) 
+					{
+					TBuf16<250> msg;
+					msg.Format(KMsg, &path);
+					test.Printf(msg);
+					FailIfError(r);
+					}
+				i++;
+				}
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}	
+		
+		if(gTypes >= 2) 
+			{
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName, 2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			
+			i = 0;
+			startTime.HomeTime();
+			while(i < aN) 
+				{ 
+				FileNamesGeneration(buffer, 20, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				if(r != KErrNone) 
+					{
+					TBuf16<250> msg;
+					msg.Format(KMsg, &path);
+					test.Printf(msg);
+					FailIfError(r);
+					}
+				i++;
+				}	
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName, 3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			i = 0;
+			startTime.HomeTime();
+			while(i < aN) 
+				{
+				if(1 == (i % 2)) 	FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				else  				FileNamesGeneration(buffer, 20, i, i%3+1) ;
+					
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				if(r != KErrNone) 
+					{
+					TBuf16<250> msg;
+					msg.Format(KMsg, &path);
+					test.Printf(msg);
+					FailIfError(r);
+					}
+				i++;
+				}
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);
+			}	
+		}
+
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+				
+	return(KErrNone);
+	}
+
+/**  Deletes all files in a given directory using wildcards
+
+	@param aN 		Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C TInt DelAllFiles2(TInt aN, TInt aStep)
+	{
+	TInt r = 0;
+	
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			dirtemp.Format(KDirMultipleName, 1, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			
+			r = fMan->Delete(directory);
+			FailIfError(r);
+
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime); 
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		if(gTypes >= 2) 
+			{		
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName, 2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName,3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	delete fMan;
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+
+	return(KErrNone);
+	}
+
+/** Delete last.txt with two threads accessing the current directory and 
+	creating/deleting a file with RFs::Delete
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelFileM1(TInt aN, TInt aStep) 
+	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+    TBuf16<100> dir4;
+	
+	TInt r = 0;
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; 
+
+	dir1 = gSessionPath;
+	dir2 = gSessionPath;
+	dir3 = gSessionPath;
+	
+	dir4.Format(KDirMultipleName, 1, aN);
+	dir1.Append(dir4);
+	dir4.Format(KDirMultipleName, 2, aN);
+	dir2.Append(dir4);	
+	dir4.Format(KDirMultipleName, 3, aN);
+	dir3.Append(dir4);
+	
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{	
+			gDelEntryDir = dir1;
+			gDelEntryDir2 = dir1;
+			dir1.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{
+			gDelEntryDir = dir2;
+			gDelEntryDir2 = dir2;
+			
+			dir2.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+				
+			DoTestKill();
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 3) 
+			{
+			gDelEntryDir = dir3;
+			gDelEntryDir2 = dir3;
+			
+			dir3.Append(KCommonFile);
+
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete last.txt by opening it and with two threads accessing the current 
+	directory and creating/deleting a file with CFileMan::Delete
+
+	@param aN 		Number of files in the directory
+	@param aStep 	Test step 
+*/
+LOCAL_C void DelFileM2(TInt aN, TInt aStep) 
+ 	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+    TBuf16<100> dir4;
+	
+	TInt r = 0;
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; 
+
+	CFileMan* fMan = CFileMan::NewL(TheFs);
+
+	dir1 = gSessionPath;
+	dir2 = gSessionPath;
+	dir3 = gSessionPath;
+	
+	dir4.Format(KDirMultipleName, 1, aN);
+	dir1.Append(dir4);
+	dir4.Format(KDirMultipleName, 2, aN);
+	dir2.Append(dir4);	
+	dir4.Format(KDirMultipleName, 3, aN);
+	dir3.Append(dir4);
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			gDelEntryDir = dir1;
+			gDelEntryDir2 = dir1;
+			
+			dir1.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+			
+			r = fMan->Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{
+			gDelEntryDir = dir2;
+			gDelEntryDir2 = dir2;
+			
+			dir2.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			DoTestKill();
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 3) 
+			{
+			gDelEntryDir = dir3;
+			gDelEntryDir2 = dir3;
+			dir3.Append(KCommonFile);
+
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	delete fMan;
+
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+
+	}
+
+/** Delete all files with two threads accessing the current directory and creating/deleting a file
+	with RFs::Delete
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelAllM1(TInt aN, TInt aStep) 
+	{
+	TInt i = 0, r = 0;
+	
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	
+	TBuf16<50> path;
+	TBuf16<50> buffer(50); 	
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+	
+	if(aN <= gFilesLimit) 
+		{
+		// Start the noise in the background
+		gDelEntryDir = directory;
+		gDelEntryDir2 = directory;
+		DoTest(DeleteEntryAccess);
+		
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			dirtemp.Format(KDirMultipleName, 1, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			i = 0;
+					
+			startTime.HomeTime();
+			while(i < aN) 
+				{
+				FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}
+			endTime.HomeTime();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 2) 
+			{
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName, 2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			i = 0;
+			startTime.HomeTime();
+			while(i < aN) 
+			 	{
+				FileNamesGeneration(buffer, 20, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}	
+			endTime.HomeTime();
+
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName,3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			
+			i = 0;
+			startTime.HomeTime();
+			while(i < aN) 
+				{
+				if(1 == (i % 2)) 	FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				else  		FileNamesGeneration(buffer, 20, i, i%3+1) ;
+					
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}
+			endTime.HomeTime();
+
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		// Stop the noise in the background
+		DoTestKill();
+		}
+
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete all files with two threads accessing the same directory and creating/deleting a file
+	with CFileMan::Delete
+
+	@param aN Number of files in the directory	
+	@param aStep 	Test step
+*/
+LOCAL_C void DelAllM2(TInt aN, TInt aStep) 
+	{
+	TInt r = 0;
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+
+	CFileMan* fMan = CFileMan::NewL(TheFs);
+	
+	if(aN <= gFilesLimit) 
+		{	
+		// Start the noise in the background
+		gDelEntryDir = directory;
+		gDelEntryDir2 = directory;
+		DoTest(DeleteEntryAccess);
+		
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			dirtemp.Format(KDirMultipleName, 1, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName, 2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			endTime.HomeTime();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			
+			}
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName, 3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			endTime.HomeTime();
+			
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		// Stop the noise in the background	
+		DoTestKill();
+		}
+	
+	delete fMan;
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+
+/** Delete last.txt file with two threads accessing different directories and 
+	creating/deleting a file in them 
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelFileMD1(TInt aN, TInt aStep) 
+	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+    TBuf16<100> dir4;
+    TBuf16<100> temp;
+		
+	TInt r = 0;
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+
+
+	dir1 = gSessionPath;
+	dir2 = gSessionPath;
+	dir3 = gSessionPath;
+	
+	dir4.Format(KDirMultipleName, 1, aN);
+	dir1.Append(dir4);
+	dir4.Format(KDirMultipleName, 2, aN);
+	dir2.Append(dir4);	
+	dir4.Format(KDirMultipleName, 3, aN);
+	dir3.Append(dir4);
+
+
+	temp = gSessionPath;
+	dir4.Format(KDirMultipleName, 3 ,300);
+	temp.Append(dir4);
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			gDelEntryDir = dir1;
+			gDelEntryDir2=temp;
+			dir1.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+			
+			r = TheFs.Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{	
+			gDelEntryDir = dir2;
+			
+			dir2.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			DoTestKill();
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+	
+		if(gTypes >= 3) 
+			{
+			gDelEntryDir = dir3;
+			
+			dir3.Append(KCommonFile);
+
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete last.txt file with two threads accessing different directories and 
+	creating/deleting a file in them 
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelFileMD2(TInt aN, TInt aStep) 
+	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+    TBuf16<100> dir4;
+    TBuf16<100> temp;
+	
+	TInt r = 0;
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	
+	dir1 = gSessionPath;
+	dir2 = gSessionPath;
+	dir3 = gSessionPath;
+	
+	dir4.Format(KDirMultipleName, 1, aN);
+	dir1.Append(dir4);
+	dir4.Format(KDirMultipleName, 2, aN);
+	dir2.Append(dir4);	
+	dir4.Format(KDirMultipleName, 3, aN);
+	dir3.Append(dir4);
+	
+	
+	temp=gSessionPath;
+	dir4.Format(KDirMultipleName, 3, 300);
+	temp.Append(dir4);
+	
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			gDelEntryDir = dir1;
+			gDelEntryDir2=temp;
+			
+			dir1.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+			
+			r = fMan->Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{	
+			dir4=dir2;
+			gDelEntryDir = dir4;
+
+			dir2.Append(KCommonFile);
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			DoTestKill();
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		if(gTypes >= 3) 
+			{
+			dir4=dir3;
+			gDelEntryDir = dir4;
+		
+			dir3.Append(KCommonFile);
+
+			
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	delete fMan;
+
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete all files with two threads accessing different directories and 
+	creating/deleting a file in them using RFs::Delete
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelAllMD1(TInt aN, TInt aStep) 
+	{
+	TInt i = 0,r = 0;
+	
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	TBuf16<50> temp;
+	TBuf16<50> dir4;
+
+
+	TBuf16<50> path;
+	TBuf16<50> buffer(50); 	
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+
+	
+	temp=gSessionPath;
+	dir4.Format(KDirMultipleName, 3, 300);
+	temp.Append(dir4);
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			dirtemp.Format(KDirMultipleName,1, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			gDelEntryDir = directory;
+			gDelEntryDir2 = temp;
+
+			i = 0;
+			
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+			while(i < aN) 
+				{
+				FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 2) 
+			{
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName,2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			gDelEntryDir = directory;
+			DoTest(DeleteEntryAccess);
+
+			i = 0;
+			startTime.HomeTime();
+			while(i<aN) 
+				{
+				FileNamesGeneration(buffer, 20, i, i%3+1) ;
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}	
+			endTime.HomeTime();
+			DoTestKill();
+
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName,3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			
+			gDelEntryDir = directory;
+			DoTest(DeleteEntryAccess);
+			i = 0;
+			startTime.HomeTime();
+			while(i<aN) 
+				{
+				if(1==(i%2)) 	FileNamesGeneration(buffer, 8, i, i%3+1) ;
+				else  		FileNamesGeneration(buffer, 20, i, i%3+1) ;
+					
+				path = directory;
+				path.Append(buffer);
+				r = TheFs.Delete(path);
+				FailIfError(r);
+				i++;
+				}
+			endTime.HomeTime();
+			DoTestKill();
+
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete all files with two threads accessing different directories and 
+	creating/deleting a file in them using CFileMan::Delete
+
+	@param aN 		Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelAllMD2(TInt aN, TInt aStep) 
+	{
+	TInt r = 0;
+	TBuf16<50> directory;
+	TBuf16<50> dirtemp;
+	TBuf16<50> dir4;	
+	TBuf16<50> temp;	
+	
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+
+	
+	// Creating directory for being accessed by other thread
+	temp=gSessionPath;
+	dir4.Format(KDirMultipleName, 3, 300);
+	temp.Append(dir4);
+	gDelEntryDir2=temp;
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			// all 8.3 
+			dirtemp.Format(KDirMultipleName,1, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+
+			gDelEntryDir = directory;
+
+			DoTest(DeleteEntryAccess);
+			
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);	
+			
+			endTime.HomeTime();
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			DoTestKill();
+			}
+		
+		if(gTypes >= 2) 
+			{
+			// all 20.3 chars
+			dirtemp.Format(KDirMultipleName,2, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			gDelEntryDir = directory;
+
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		if(gTypes >= 3) 
+			{
+			// 50/50 
+			dirtemp.Format(KDirMultipleName,3, aN);
+			directory = gSessionPath;
+			directory.Append(dirtemp);
+			gDelEntryDir = directory;
+
+			DoTest(DeleteEntryAccess);
+
+			startTime.HomeTime();
+			directory.Append(_L("F*.*"));
+			r = fMan->Delete(directory);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			DoTestKill();
+			
+			timeTaken=endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	delete fMan;
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+
+/** Delete last.txt with RFs::Delete
+
+	@param aN 		Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelFile1(TInt aN, TInt aStep) 
+	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+    TBuf16<100> dir4;
+	
+	TInt r = 0;
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+	
+	dir1 = gSessionPath;
+	dir2 = gSessionPath;
+	dir3 = gSessionPath;
+	
+	dir4.Format(KDirMultipleName, 1, aN);
+	dir1.Append(dir4);
+	dir4.Format(KDirMultipleName, 2, aN);
+	dir2.Append(dir4);	
+	dir4.Format(KDirMultipleName, 3, aN);
+	dir3.Append(dir4);
+
+	dir1.Append(KCommonFile);
+	dir2.Append(KCommonFile);
+	dir3.Append(KCommonFile);
+
+	if(aN <= gFilesLimit) 
+		{
+		if(gTypes >= 1) 
+			{
+			startTime.HomeTime();
+			
+			r = TheFs.Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		if(gTypes >= 2) 
+			{
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		if(gTypes >= 3) 
+			{
+			startTime.HomeTime();
+
+			r = TheFs.Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		}
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Delete last.txt with CFileMan::Delete
+
+	@param aN Number of files in the directory
+	@param aStep 	Test step
+*/
+LOCAL_C void DelFile2(TInt aN, TInt aStep) 
+	{
+	TBuf16<100> dir1;
+	TBuf16<100> dir2;
+	TBuf16<100> dir3;
+	TBuf16<100> dir4;
+
+	TInt r = 0;
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;  
+	
+	if(aN <= gFilesLimit) 
+		{
+		CFileMan* fMan = CFileMan::NewL(TheFs);
+		
+		dir1 = gSessionPath;
+		dir2 = gSessionPath;
+		dir3 = gSessionPath;
+
+		dir4.Format(KDirMultipleName, 1, aN);
+		dir1.Append(dir4);
+		dir4.Format(KDirMultipleName, 2, aN);
+		dir2.Append(dir4);
+		dir4.Format(KDirMultipleName, 3, aN);
+		dir3.Append(dir4);
+			
+		dir1.Append(KCommonFile);
+		dir2.Append(KCommonFile);
+		dir3.Append(KCommonFile);
+
+		if(gTypes >= 1) 
+			{
+			startTime.HomeTime();
+			
+			r = fMan->Delete(dir1);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+		
+		if(gTypes >= 2) 
+			{
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir2);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit );
+			}
+
+		if(gTypes >= 3) 
+			{
+			startTime.HomeTime();
+
+			r = fMan->Delete(dir3);
+			FailIfError(r);
+			
+			endTime.HomeTime();
+			timeTaken = endTime.MicroSecondsFrom(startTime);
+			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);
+			} 
+		
+		delete fMan;
+		}
+	
+	gWriting = ETrue; User::After(1000000);
+	PrintResult(aStep, 1, aN);
+	PrintResultTime(aStep, 2, timeTaken1);
+	PrintResultTime(aStep, 3, timeTaken2);
+	PrintResultTime(aStep, 4, timeTaken3);
+	gWriting = EFalse;
+	}
+
+/** Tests the deletion of one file with both API: RFs::Delete and CFileMan::Delete
+
+	@param aSelector Configuration in case of manual execution
+*/
+LOCAL_C TInt TestDelEntry(TAny* aSelector)
+	{
+	// Precondition: the drive already filled with the right files
+
+	TInt i = 100;
+	TInt testStep = 1;
+	
+	Validate(aSelector);
+
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)	
+			DelFile1(i, testStep++);
+		i += 100;
+		}
+	
+	ReCreateLast();
+	gTestCase++;
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt, CFileMan::Delete\n"), gTestHarness, gTestCase);
+		
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelFile2(i, testStep++);
+		i += 100;
+		}
+	
+	gTestCase++;
+	
+	return(KErrNone);
+	}
+
+/** Tests the deletion of all the files in a directory with both API: 
+	RFs::Delete and CFileMan::Delete
+
+	@param aSelector Configuration in case of manual execution
+*/
+LOCAL_C TInt TestDelAllFiles(TAny* aSelector)
+	{
+	// Precondition: drive already filled with the right files
+
+	TInt i = 100;
+	TInt testStep = 1;
+	
+	Validate(aSelector);
+
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllFiles1(i, testStep++);
+		i += 100;
+		}
+
+	TestFileCreate(aSelector);
+	gTestCase++;
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all, CFileMan::Delete\n"), gTestHarness, gTestCase);	
+
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllFiles2(i, testStep++);
+		i += 100;
+		}
+
+	gTestCase++;
+	return(KErrNone);
+	}
+
+/** Tests the deletion of last.txt in a directory with both API: 
+	RFs::Delete and CFileMan::Delete while 2 other threads accessing the directory
+
+	@param aSelector Configuration in case of manual execution
+*/
+LOCAL_C TInt TestDelMultSame(TAny* aSelector)
+	{
+	TInt i = 100;
+	TInt testStep = 1;
+
+
+	Validate(aSelector);
+
+	TestFileCreate(aSelector);
+	
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt mult. clients del in same dir, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelFileM1(i, testStep++);
+		i += 100;
+		}
+
+	ReCreateLast();
+	gTestCase++;	
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt mult. clients del in same dir, CFileMan::Delete\n"), gTestHarness, gTestCase);
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			{
+			DelFileM2(i, testStep);
+			testStep++;
+			}
+		i += 100;	
+		}
+
+	ReCreateLast();
+	gTestCase++;
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all mult. clients del in same dir, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllM1(i, testStep++);
+		i += 100;
+		}
+
+	TestFileCreate(aSelector);
+	gTestCase++;
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all mult. clients del in same dir, CFileMan::Delete\n"), gTestHarness, gTestCase);
+
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllM2(i, testStep++);
+		i += 100;
+		}
+
+	gTestCase++;
+	
+	return(KErrNone);
+	}
+
+
+/** Tests the deletion of last.txt in a directory with both API: 
+	RFs::Delete and CFileMan::Delete while 2 threads accessing different directories 
+	(the current and one with 300 files)
+
+	@param aSelector Configuration in case of manual execution
+*/
+LOCAL_C TInt TestDelMultDif(TAny* aSelector)
+	{
+	TInt i = 100;
+	TInt testStep = 1;
+	
+	Validate(aSelector);
+	
+	TestFileCreate(aSelector);
+	CreateDirWithNFiles(300, 3);
+	
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt mult. clients del in dif dirs, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelFileMD1(i, testStep++);
+		i += 100;
+		}
+
+	ReCreateLast();
+	gTestCase++;	
+	test.Printf(_L("#~TS_Title_%d,%d: Delete last.txt mult. clients del in dif dirs, CFileMan::Delete\n"), gTestHarness, gTestCase);
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelFileMD2(i, testStep++);
+		i += 100;
+		}
+
+	ReCreateLast();
+	gTestCase++;		
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all mult. clients del in dif dirs, RFs::Delete\n"), gTestHarness, gTestCase);
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllMD1(i, testStep++);
+		i += 100;
+		}
+
+	TestFileCreate(aSelector);
+	gTestCase++;
+	test.Printf(_L("#~TS_Title_%d,%d: Delete all mult. clients del in dif dirs, CFileMan::Delete\n"), gTestHarness, gTestCase);
+
+	
+	i = 100;
+	testStep = 1;
+	while(i <= KMaxFiles)
+		{
+		if(i == 100 || i == 1000 || i == 5000 || i == 10000)
+			DelAllMD2(i, testStep++);
+		i += 100;
+		}
+
+	gTestCase++;
+	
+	return(KErrNone);
+	}
+
+/** Goes automatically through all the options
+
+	@param aSelector Configuration in case of manual execution
+*/
+LOCAL_C TInt TestAll(TAny* aSelector)
+	{
+	Validate(aSelector);
+	
+	gFormat=ETrue; 	// The card will be formatted after this test execution
+
+	TestDelEntry(aSelector);
+	TestDelAllFiles(aSelector);
+	TestDelMultSame(aSelector);
+	TestDelMultDif(aSelector);
+	
+	return KErrNone;
+	}
+
+/** Call all tests
+
+*/
+GLDEF_C void CallTestsL()
+	{
+
+	TInt r = client.CreateLocal(0);
+	FailIfError(r);
+	
+	// Each test case of the suite has an identifyer for parsing purposes of the results
+	gTestHarness = 1; 	
+	gTestCase = 1;
+	
+	PrintHeaders(1, _L("t_fsrdel. Deletion")); 
+		
+	RThread noisy; 
+	TBuf<20> buf = _L("Noisy");
+	r = noisy.Create(buf, noise, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	FailIfError(r);
+	
+	noisy.Resume();
+
+	CSelectionBox* TheSelector = CSelectionBox::NewL(test.Console());
+	
+	if(gMode == 0) 
+		{ // Manual
+		gSessionPath=_L("?:\\");
+		TCallBack createFiles(TestFileCreate,TheSelector);
+		TCallBack delFile(TestDelEntry,TheSelector);
+		TCallBack delAllFiles(TestDelAllFiles,TheSelector);
+		TCallBack delMultSame(TestDelMultSame,TheSelector);
+		TCallBack delMultDif(TestDelMultDif,TheSelector);
+		TCallBack delAll(TestAll,TheSelector);
+		TheSelector->AddDriveSelectorL(TheFs);
+		TheSelector->AddLineL(_L("Create all files"),createFiles);
+		TheSelector->AddLineL(_L("Delete one file from each dir"),delFile);
+		TheSelector->AddLineL(_L("Delete all files"),delAllFiles);
+		TheSelector->AddLineL(_L("Delete mult clients same dir"),delMultSame);
+		TheSelector->AddLineL(_L("Delete mult clients dif dir"),delMultDif);
+		TheSelector->AddLineL(_L("Execute all options"),delAll);
+		TheSelector->Run();
+		}
+	else 
+		{ // Automatic
+		TestAll(TheSelector);
+		}
+		
+	client.Close();
+	delete TheSelector;
+	
+	noisy.Kill(KErrNone);
+	noisy.Close();	
+
+	test.Printf(_L("#~TestEnd_%d\n"), gTestHarness);
+	}