--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_fatcharsetconv_main.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1526 @@
+// 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 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\server\T_FatCharSetConv_Main.cpp
+// 
+//
+
+#define __E32TEST_EXTENSION__
+
+#include <e32test.h>
+//#include <hal.h>
+#include <f32fsys.h>
+#include <f32dbg.h>
+#include "t_server.h"
+#include "t_chlffs.h"
+#include "fat_utils.h"
+#include "T_Fatcharsetconv_Cases.h"
+
+
+RTest test(_L("T_FatCharSetConv"));
+
+using namespace Fat_Test_Utils;
+
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+
+template <class C>
+TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)
+	{
+    TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));
+    TInt r = fs.ControlIo(drv, fkn, ptrC);
+    return r;
+	}
+
+/*
+ * Presetting module, presets initial source, target and comparing direcotries.
+ * @param	aParam	test param that contains all information about a test case
+ */
+void DataGenerationL(const TTestParamAll& aParam)
+	{
+	// Setup source files
+	RBuf path;
+	path.CreateL(aParam.iSrcPrsPath);
+	
+	path[0] = (TUint16)*aParam.iSrcDrvChar;
+	if(path[0] == (TUint8)gDriveToTest)
+		{
+		SetupDirFiles(path, aParam.iSrcPrsFiles);
+		}
+	
+	if (aParam.iAPI == EGetShortName || aParam.iAPI == EGetShortNameWithDLL || aParam.iAPI == EGetShortNameWithoutDLL || aParam.iAPI == ERFsReplace || aParam.iAPI == ERFsRename ||aParam.iAPI == ERenameFile )
+		{
+		path[0] = (TUint16)*aParam.iTrgDrvChar;
+		}
+	path.Close();
+	CheckDisk();
+	}
+
+/*
+ * Test execution module
+ * @param	aParam	test param that contains all information about a test case
+ * @panic	USER:84	if return codes do not match the expected values. 	
+ */
+void DataExecutionL(const TTestParamAll& aParam, const TTCType aTCType)
+	{
+	RBuf srcCmdFile;
+	srcCmdFile.CreateL(aParam.iSrcCmdPath);
+	RBuf trgCmdFile;
+	trgCmdFile.CreateL(aParam.iTrgCmdPath);
+	RBuf srcCmd;
+	srcCmd.CreateL(aParam.iSrcPrsPath);
+	
+	if (srcCmdFile.Length() > 0)
+		{
+		srcCmdFile[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	else
+		{
+		// srcCmdFile= gSessionPath;
+		srcCmdFile[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	if (srcCmd.Length() > 0)
+		{
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	else
+		{
+		// srcCmd= gSessionPath;
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+
+	// logging for failure
+	gTCType = aTCType;
+	RBuf failedOnBuf;
+	failedOnBuf.CreateL(KExecution());
+	gTCId = aParam.iTestCaseID;
+	RBuf tcUniquePath;
+	tcUniquePath.CreateL(aParam.iSrcPrsPath);
+
+	TInt r = KErrNone;
+
+	switch(aParam.iAPI)
+		{
+		case EGetShortName:
+		case EGetShortNameWithDLL:
+		case EGetShortNameWithoutDLL:
+			{
+			__UHEAP_MARK;
+			if(aParam.iAPI == EGetShortName )
+				gLogFailureData.iAPIName = KGetShortName;
+			else if(aParam.iAPI == EGetShortNameWithDLL )
+				gLogFailureData.iAPIName = KGetShortNameWithDLL;
+			else if(aParam.iAPI == EGetShortNameWithoutDLL )
+				gLogFailureData.iAPIName = KGetShortNameWithoutDLL;
+
+				if (trgCmdFile.Length() > 0)
+					{
+					trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+					}
+				else
+					{
+					//trgCmdFile= gSessionPath;
+					trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+					}
+
+			TBuf<0x10> shortName;
+			r=TheFs.GetShortName(srcCmdFile,shortName);
+			testAndLog(r==KErrNone);
+			srcCmd.ReAllocL(srcCmd.Length() + shortName.Length());
+			srcCmd+= shortName;
+			testAndLog(srcCmd==trgCmdFile);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ELongShortConversion:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KLongShortConversion;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+
+			RBuf lgnFullPath;
+			RBuf shnFullPath;
+			TFileName longName;
+			TBuf<0x10> shortName;
+	
+			r = TheFs.GetShortName(srcCmdFile, shortName);
+			testAndLog(r==KErrNone);
+	
+			shnFullPath.CreateL(srcCmd);
+			shnFullPath.ReAllocL(srcCmd.Length() + shortName.Length());
+			shnFullPath.Append(shortName);
+			r = shnFullPath.Compare(trgCmdFile);
+			testAndLog(r==KErrNone);
+
+			r = TheFs.GetLongName(shnFullPath, longName);
+			testAndLog(r==KErrNone);
+			
+			lgnFullPath.CreateL(srcCmd);
+			lgnFullPath.ReAllocL(srcCmd.Length() + longName.Length());
+			lgnFullPath.Append(longName);
+			r = lgnFullPath.Compare(srcCmdFile);
+			testAndLog(r==KErrNone);
+			
+			lgnFullPath.Close();
+			shnFullPath.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ECreateFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName  = KCreateFile;
+			r = TheFile.Create(TheFs,srcCmdFile,EFileWrite);
+			testAndLog(r==KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EIsValidName:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KIsValidName;
+			TText badChar;
+			r=TheFs.IsValidName(srcCmdFile,badChar);
+			testAndLog(r==(TInt)ETrue);
+			r=TheFs.IsValidName(srcCmdFile);
+			testAndLog(r==(TInt)ETrue);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EMkDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KMkDir;
+			r=TheFs.MkDir(srcCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;		
+		case EMkDirAll:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KMkDirAll;
+			r=TheFs.MkDirAll(srcCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;		
+		case ERenameFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRenameFile;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+				
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+			r=TheFile.Rename(trgCmdFile);
+			testAndLog(r==KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReadFileSection:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadFileSection;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+			
+			TInt numWrite = 15;
+			TBuf8<50> writeBuf = _L8("I am going to write some junk for testing purpose");
+			TheFile.Write(writeBuf, numWrite);
+   			r=TheFile.Flush();
+   			testAndLog(r==KErrNone);
+  			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EDeleteFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KDeleteFile;
+			r=TheFs.Delete(srcCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EOpenDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KOpenDir;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReadDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadDir;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERemoveDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRemoveDir;
+			r=TheFs.RmDir(srcCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;		
+		case EIsFileInRom:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KIsFileInRom;
+			// The tested files are created on non-rom drives, which should not be found 
+			//	on rom drives
+			TUint8* ptr=TheFs.IsFileInRom(srcCmdFile);
+			testAndLog(ptr==NULL);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReplaceFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReplaceFile;
+			r=TheFile.Replace(TheFs, srcCmdFile ,EFileWrite);
+			testAndLog(r==KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EOperateOnFileNames:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KOperateOnFileNames;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead);
+			testAndLog(r == KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileModify:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileModify;
+			TTime time;
+			r=TheFs.Modified(srcCmdFile,time);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileAttributes:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileAttributes;
+			TUint att;
+			r=TheFs.Att(srcCmdFile,att);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsEntry:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRFsEntry;
+			TEntry entryDetail;
+			r=TheFs.Entry(srcCmdFile, entryDetail);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsReplace:
+			{
+			__UHEAP_MARK;	
+			gLogFailureData.iAPIName = KRFsReplace;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			r=TheFs.Replace(srcCmdFile,trgCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsRename:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRFsRename;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				} 
+			r=TheFs.Rename(srcCmdFile,trgCmdFile);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}	
+			break;
+		case EGetDir:	
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KGetDir;
+			CDir *anEntryList;
+			r=TheFs.GetDir(srcCmdFile,KEntryAttNormal,ESortByName,anEntryList);
+			testAndLog(r==KErrNone);
+			delete anEntryList;
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileTemp:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileTemp;
+			TFileName tempFileName;
+			r=TheFile.Temp(TheFs,srcCmdFile,tempFileName,EFileWrite);
+			testAndLog(r == KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReadFromFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadFromFile;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+			
+			TBuf8<200> writeBuf = _L8("I am going to write something to the file and then read from the specified position to test an overload of RFIle::Read");
+			TInt numWrite = 50;
+   			TheFile.Write(writeBuf, numWrite);
+   			testAndLog(r==KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}	
+		break;
+		case EWriteToFile:
+			{
+			__UHEAP_MARK;						
+			gLogFailureData.iAPIName = KWriteToFile;
+
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+
+			TBuf8<200> writeBuf = _L8("I am going to write something to the file and then read from the specified position to test an overload of RFIle::Read");
+			TInt numWrite = 50;
+   			TheFile.Write(writeBuf, numWrite);
+   			testAndLog(r==KErrNone);
+   			r=TheFile.Flush();
+   			testAndLog(r==KErrNone);
+			TheFile.Close();
+   			__UHEAP_MARKEND;
+			}	
+			
+		break;
+	 	default:
+		break;
+
+		}
+//	test.Printf(_L("DataExecution::\tTest case %d passed\n"),aParam.iTestCaseID);
+
+	failedOnBuf.Close();
+	tcUniquePath.Close();
+
+	srcCmdFile.Close();
+	trgCmdFile.Close();
+	srcCmd.Close();
+	CheckDisk();
+	}
+
+void DataVerificationL(const TTestParamAll& aParam, const TTCType aTCType)
+	{
+	RBuf srcCmdFile;
+	srcCmdFile.CreateL(aParam.iSrcCmdPath);
+	RBuf trgCmdFile;
+	trgCmdFile.CreateL(aParam.iTrgCmdPath);
+	RBuf srcCmd;
+	srcCmd.CreateL(aParam.iSrcPrsPath);
+
+	if (srcCmdFile.Length() > 0)
+		{
+		srcCmdFile[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	else
+		{
+		//srcCmdFile= gSessionPath;
+		srcCmdFile[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+		
+	if (srcCmd.Length() > 0)
+		{
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	else
+		{
+		//srcCmd= gSessionPath;
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+
+	// logging for failure
+	gTCType = aTCType;
+	RBuf failedOnBuf;
+	failedOnBuf.CreateL(KVerification());
+	gTCId = aParam.iTestCaseID;
+	RBuf tcUniquePath;
+	tcUniquePath.CreateL(aParam.iSrcPrsPath);
+
+	TInt r = KErrNone;
+	switch(aParam.iAPI)
+		{
+		case EGetShortName:
+		case EGetShortNameWithDLL:
+		case EGetShortNameWithoutDLL:
+			{
+			__UHEAP_MARK;
+			if(aParam.iAPI == EGetShortName )
+				gLogFailureData.iAPIName = KGetShortName;
+			else if(aParam.iAPI == EGetShortNameWithDLL )
+				gLogFailureData.iAPIName = KGetShortNameWithDLL;
+			else if(aParam.iAPI == EGetShortNameWithoutDLL )
+				gLogFailureData.iAPIName = KGetShortNameWithoutDLL;
+
+				if (trgCmdFile.Length() > 0)
+					{
+					trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+					}
+				else
+					{
+					//trgCmdFile= gSessionPath;
+					trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+					}
+
+			TBuf<0x10> shortName;
+			r=TheFs.GetShortName(srcCmdFile,shortName);
+			testAndLog(r==KErrNone);
+			if(r==KErrNone)
+				{
+				srcCmd.ReAllocL(srcCmd.Length() + shortName.Length());
+				srcCmd+= shortName;
+				testAndLog(srcCmd==trgCmdFile);
+				}
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ELongShortConversion:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KLongShortConversion;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+
+			RBuf lgnFullPath;
+			RBuf shnFullPath;
+			TFileName longName;
+			TBuf<0x10> shortName;
+	
+			r = TheFs.GetShortName(srcCmdFile, shortName);
+			testAndLog(r==KErrNone);
+	
+			if(r==KErrNone)
+				{
+				shnFullPath.CreateL(srcCmd);
+				shnFullPath.ReAllocL(srcCmd.Length() + shortName.Length());
+				shnFullPath.Append(shortName);
+				r = shnFullPath.Compare(trgCmdFile);
+				testAndLog(r==KErrNone);
+
+				r = TheFs.GetLongName(shnFullPath, longName);
+				testAndLog(r==KErrNone);
+				
+				lgnFullPath.CreateL(srcCmd);
+				lgnFullPath.ReAllocL(srcCmd.Length() + longName.Length());
+				lgnFullPath.Append(longName);
+				r = lgnFullPath.Compare(srcCmdFile);
+				testAndLog(r==KErrNone);
+
+				lgnFullPath.Close();
+				shnFullPath.Close();
+				}
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ECreateFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KCreateFile;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EIsValidName:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KIsValidName;
+			TText badChar;
+			r=TheFs.IsValidName(srcCmdFile,badChar);
+			testAndLog(r);
+			r=TheFs.IsValidName(srcCmdFile);
+			testAndLog(r);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EMkDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KMkDir;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EMkDirAll:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KMkDirAll;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERenameFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRenameFile;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNotFound);
+			// r = TheFile.Open(TheFs, trgCmdFile, EFileRead|EFileWrite);
+			// testAndLog(r == KErrNone);
+			// TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReadFileSection:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadFileSection;
+			TBool isFileOpen = EFalse;
+			r=TheFs.IsFileOpen(srcCmdFile,isFileOpen);
+			testAndLog(r==KErrNone);
+			if(isFileOpen)
+				{
+				TheFile.Close();
+				}
+			else
+				{
+				TInt numRead = 15;
+				TBuf8<50> readBuf;
+				r=TheFs.ReadFileSection(srcCmdFile, 0, readBuf, numRead);
+				testAndLog(r==KErrNone);
+				}
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EDeleteFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KDeleteFile;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNotFound);
+			// TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EOpenDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KOpenDir;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReadDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadDir;
+			TEntry entry;
+			TInt dirEntryCount = 0;
+			r=TheDir.Open(TheFs,srcCmdFile,KEntryAttMaskSupported);
+			testAndLog(r==KErrNone);
+			FOREVER
+				{
+				r = TheDir.Read(entry);
+				if(r == KErrEof)
+					{
+					break;
+					}
+				dirEntryCount++;
+				}
+			TheDir.Close();
+			testAndLog(dirEntryCount == 4);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERemoveDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRemoveDir;
+			r = TheDir.Open(TheFs, srcCmdFile, KEntryAttMaskSupported);
+			testAndLog(r == KErrPathNotFound);
+			// TheDir.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EIsFileInRom:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KIsFileInRom;
+			TUint8* ptr=TheFs.IsFileInRom(srcCmdFile);
+			// file should not be in ROM
+			testAndLog(ptr==NULL)
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EReplaceFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReplaceFile;
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+			TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EOperateOnFileNames:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KOperateOnFileNames;
+			
+			TFileName realFileNameInFS;
+			TFileName fullFileName;
+			TFileName fileName;
+
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead);
+			testAndLog(r == KErrNone);
+
+			if(r==KErrNone)
+				{
+				r=TheFile.FullName(fullFileName);
+				testAndLog(r==KErrNone);
+				testAndLog(fullFileName==srcCmdFile);
+				
+				TInt length = srcCmdFile.Length()-srcCmd.Length();
+				
+				r=TheFile.Name(fileName);
+				testAndLog(r==KErrNone);
+				
+				TBuf<50> tempFileName;
+				tempFileName = srcCmdFile.Right(length);
+				testAndLog(fileName==tempFileName);
+				testAndLog(length==fileName.Length());
+
+				r=TheFs.RealName(srcCmdFile,realFileNameInFS);
+				testAndLog(r==KErrNone);
+				testAndLog(realFileNameInFS==srcCmdFile);
+				TheFile.Close();
+				}
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileModify:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileModify;
+			TTime tempTime;
+			r=TheFs.Modified(srcCmdFile,tempTime);
+			testAndLog(r==KErrNone);
+			tempTime.HomeTime();
+			r=TheFs.SetModified(srcCmdFile,tempTime);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileAttributes:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileAttributes;
+			TUint att;
+			r=TheFs.Att(srcCmdFile,att);
+			testAndLog(r==KErrNone);
+			r=TheFs.SetAtt(srcCmdFile,KEntryAttHidden,0);
+			testAndLog(r==KErrNone);
+			r=TheFs.Att(srcCmdFile,att);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsEntry:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRFsEntry;
+			TEntry entryDetail;
+			r=TheFs.Entry(srcCmdFile,entryDetail);
+			testAndLog(r==KErrNone);
+			TTime time;
+			time.HomeTime();
+			r=TheFs.SetEntry(srcCmdFile, time, KEntryAttHidden, KEntryAttNormal);
+			testAndLog(r==KErrNone);
+			r=TheFs.Entry(srcCmdFile, entryDetail);
+			testAndLog(r==KErrNone);
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsReplace:
+			{
+			__UHEAP_MARK;	
+			gLogFailureData.iAPIName = KRFsReplace;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNotFound);
+			// r = TheFile.Open(TheFs, trgCmdFile, EFileRead|EFileWrite);
+			// testAndLog(r == KErrNone);
+			// TheFile.Close();
+			__UHEAP_MARKEND;
+			}
+			break;
+		case ERFsRename:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KRFsRename;
+			if (trgCmdFile.Length() > 0)
+				{
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				//trgCmdFile= gSessionPath;
+				trgCmdFile[0] = (TUint16)*aParam.iTrgDrvChar;
+				} 
+			TInt len=srcCmdFile.Length();
+			if(srcCmdFile[--len]=='\\')
+				{
+				r = TheDir.Open(TheFs, srcCmdFile, KEntryAttMaskSupported);
+				testAndLog(r == KErrPathNotFound);
+				// r = TheDir.Open(TheFs, trgCmdFile, KEntryAttMaskSupported);
+				// testAndLog(r == KErrNone);			
+				// TheDir.Close();
+				}
+			else
+				{
+				r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+				testAndLog(r == KErrNotFound);
+				// r = TheFile.Open(TheFs, trgCmdFile, EFileRead|EFileWrite);
+				// testAndLog(r == KErrNone);
+				// TheFile.Close();
+				}
+			__UHEAP_MARKEND;			
+			}
+			break;
+		case EGetDir:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KGetDir;
+			CDir *anEntryList;
+			r=TheFs.GetDir(srcCmdFile,KEntryAttNormal,ESortByName,anEntryList);
+			testAndLog(r==KErrNone);
+			delete anEntryList;
+			__UHEAP_MARKEND;
+			}
+			break;
+		case EFileTemp:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KFileTemp;
+			TFileName tempFileName;
+			r=TheFile.Temp(TheFs,srcCmdFile,tempFileName,EFileWrite);
+			testAndLog(r == KErrNone);
+			TheFile.Close();
+			r = TheFile.Create(TheFs, tempFileName, EFileRead|EFileWrite);
+			testAndLog(r == KErrAlreadyExists);
+			__UHEAP_MARKEND;
+			}			
+			break;
+		case EReadFromFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KReadFromFile;
+			
+			TInt start=0, readLen=15, readPos=10;
+			TBuf8<200> readBuf;
+			TInt numWritten = 50;
+
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+
+			if(r==KErrNone)
+				{
+				r=TheFile.Seek(ESeekStart,start);
+		  		testAndLog(r==KErrNone);
+
+				readBuf.SetLength(0);
+				r=TheFile.Read(readBuf);
+				testAndLog(r == KErrNone);
+				testAndLog(numWritten == readBuf.Length());
+				
+				//An overload of RFile::Read(), read specified no.of bytes.
+	   			r=TheFile.Seek(ESeekStart,start);
+	  			testAndLog(r==KErrNone);
+	  			
+				readBuf.SetLength(0);
+				TheFile.Read(readBuf,readLen);
+				testAndLog(r == KErrNone);
+				testAndLog(readLen == readBuf.Length());
+				
+				//An overload of RFile::Read(), read from the specified position.
+				readBuf.SetLength(0);
+				r=TheFile.Read(readPos,readBuf);
+				testAndLog(r == KErrNone);
+				testAndLog(numWritten-readPos == readBuf.Length());
+				TheFile.Close();
+				}
+			__UHEAP_MARKEND;
+			}	
+			break;	
+		case EWriteToFile:
+			{
+			__UHEAP_MARK;
+			gLogFailureData.iAPIName = KWriteToFile;
+			
+			r = TheFile.Open(TheFs, srcCmdFile, EFileRead|EFileWrite);
+			testAndLog(r == KErrNone);
+
+			if(r==KErrNone)
+				{
+				TInt writeLen=20, writePos=10, start=0, readLen=0;
+				TBuf8<200> writeBuf = _L8("I am going to write something to the file and then read from the specified position to test an overload of RFIle::Read");
+				TInt numWritten = writeBuf.Length();
+				TBuf8<200> readBuf;
+				
+	   			TheFile.Write(writeBuf);
+	   			r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+	   			
+	   			r=TheFile.Seek(ESeekStart,start);
+	  			testAndLog(r==KErrNone);
+	  		
+	   			readBuf.SetLength(0);
+	   			r=TheFile.Read(readBuf);
+	   			testAndLog(r==KErrNone);
+	   			readLen = readBuf.Length();
+	   			testAndLog(numWritten == readLen);
+	   			
+	   			r=TheFile.SetSize(0);
+	   			testAndLog(r==KErrNone);
+	   			
+	   			//An overload of RFile::Write(), write specified no.of bytes.
+	   			TheFile.Write(writeBuf,writeLen);
+	   			r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+	   			
+	   			r=TheFile.Seek(ESeekStart,start);
+	  			testAndLog(r==KErrNone);
+				
+				readBuf.SetLength(0);
+	   			r=TheFile.Read(readBuf);
+	   			testAndLog(r==KErrNone);
+	   			readLen = readBuf.Length();
+	   			testAndLog(writeLen==readLen);
+	   			
+				r=TheFile.SetSize(0);
+	   			testAndLog(r==KErrNone);
+	   			
+	   			//An overload of RFile::Write(), write to a particular position.
+	   			TBuf8<50> testBuf = _L8("Testing different variants of RFile::Write APIs");   		
+	    		TheFile.Write(testBuf);
+	    		r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+				
+	   			TheFile.Write(writePos,writeBuf);
+	   			r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+	   			
+	      		r=TheFile.Seek(ESeekStart,start);
+	  			testAndLog(r==KErrNone);
+	  			
+	  			readBuf.SetLength(0);
+	   			r=TheFile.Read(readBuf);
+	   			testAndLog(r==KErrNone);
+	   			readLen = readBuf.Length();
+	   			testAndLog(numWritten + writePos == readLen);
+	   			
+				r=TheFile.SetSize(0);
+	   			testAndLog(r==KErrNone);
+	   			
+	   			//An overload of RFile::Write(), write to a particular position and specified no. of bytes.
+	   			TInt size;
+	    		TheFile.Write(testBuf);
+	    		r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+			
+	   			TheFile.Write(writePos,writeBuf,writeLen);
+	   			r=TheFile.Flush();
+	   			testAndLog(r==KErrNone);
+	   			
+	   			r=TheFile.Seek(ESeekStart,start);
+	  			testAndLog(r==KErrNone);
+	  			
+	  			readBuf.SetLength(0);
+	   			r=TheFile.Read(readBuf);
+	   			testAndLog(r==KErrNone);
+	   			
+	   			TInt newSize = testBuf.Length()-(writePos+writeLen);
+	   			if(newSize < testBuf.Length())
+	   				{
+	   				size = testBuf.Length();
+	   				}
+	   			else
+	   				size = newSize;
+	   			readLen = readBuf.Length();
+	   			testAndLog(readLen==size);
+
+	   			r=TheFile.SetSize(0);
+	   			testAndLog(r==KErrNone);
+
+	   			TheFile.Close();
+				}
+   			__UHEAP_MARKEND;
+			}
+			break;
+	 	default:
+			break;
+		}
+//	test.Printf(_L("DataVerification::\tTest case %d passed\n"),aParam.iTestCaseID);
+
+	failedOnBuf.Close();
+	tcUniquePath.Close();
+
+	srcCmdFile.Close();
+	trgCmdFile.Close();
+	srcCmd.Close();
+	CheckDisk();
+	}
+	
+void DeletePathAfterTest(const TTestParamAll& aParam)
+	{
+	TFileName path = aParam.iSrcPrsPath;
+	if (path.Length() == 0)
+		{
+		test.Printf(_L("ERROR<SetupDirFiles()>: Zero length src path!\n"));
+		test(EFalse);
+		}
+
+	path[0] = (TUint16)*aParam.iSrcDrvChar;
+	TInt idx = path.Find(_L("Src\\"));
+	path.Delete(idx,path.Length()-idx);
+	RmDir(path);
+	}
+
+
+/*
+ * Do all basic binary test cases defined in gBasicUnitaryTestCases[]
+ */
+void DoAllBasicUnitaryTestsL(const TTestCaseUnitaryBasic aBasicUnitaryTestCaseGroup[],
+									TTestSwitches& aSwitches, TBool aIsWithDLL)
+	{
+	TTestParamAll* 	nextTestCase = new(ELeave) TTestParamAll();
+	
+	TInt i = 0;
+	
+	// Reset the Test Log Data
+	ClearTCLogData();
+
+	while(SearchTestCaseByArrayIdx(i, aBasicUnitaryTestCaseGroup,
+							*nextTestCase, aIsWithDLL) == KErrNone)
+		{
+		TTime startTime;
+		TTime endTime;
+		startTime.HomeTime();
+		if(aSwitches.iExeOnSymbian || aSwitches.iExeOnWindows)
+			{
+			DataGenerationL(*nextTestCase);
+			DataExecutionL(*nextTestCase, EUnitaryTest);
+			}
+		if(aSwitches.iVerOnSymbian || aSwitches.iVerOnWindows)
+			{
+			DataVerificationL(*nextTestCase, EUnitaryTest);
+			DeletePathAfterTest(*nextTestCase);
+			}
+			
+		CheckDisk();
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken(0);
+		timeTaken = endTime.MicroSecondsFrom(startTime);
+
+//		test.Printf(_L("Test Case Id : %d\n"),(*nextTestCase).iTestCaseID);
+//		TInt time=0;
+//		time=I64LOW(timeTaken.Int64()/1000);
+//		test.Printf(_L("Time Taken by test case %d = %d mS \n"),nextTestCase.iTestCaseID,time);
+		++i;
+		}
+	delete nextTestCase;
+	}
+		
+/*
+ * Do all basic binary test cases defined in gBasicBinaryTestCases[]
+ */
+void DoAllBasicBinaryTestsL(const TTestCaseBinaryBasic aBasicBinaryTestCaseGroup[],
+							TTestSwitches& aSwitches, TBool aIsWithDLL)
+	{
+	TTestParamAll*	nextTestCase = new(ELeave) TTestParamAll();
+	
+	TInt i = 0;
+	
+	// Reset the Test Log Data
+	ClearTCLogData();
+	
+	while (SearchTestCaseByArrayIdx(i, aBasicBinaryTestCaseGroup,
+							*nextTestCase, aIsWithDLL) == KErrNone)
+		{
+		if (aIsWithDLL)
+			{
+			if(((aBasicBinaryTestCaseGroup[i].iBasic.iAPI==EGetShortNameWithoutDLL)))
+				{
+				++i;
+				continue;
+				}
+			}
+		else
+			{
+			if(((aBasicBinaryTestCaseGroup[i].iBasic.iAPI== EGetShortNameWithDLL) || (aBasicBinaryTestCaseGroup[i].iBasic.iAPI==ELongShortConversion)) )
+				{
+				++i;
+				continue;
+				}
+			}
+		TTime startTime;
+		TTime endTime;
+		startTime.HomeTime();
+
+		if(aSwitches.iExeOnSymbian || aSwitches.iExeOnWindows) 
+			{
+			DataGenerationL(*nextTestCase);
+			DataExecutionL(*nextTestCase, EBinaryTest);
+			}
+		if(aSwitches.iVerOnSymbian || aSwitches.iVerOnWindows)
+			{
+			DataVerificationL(*nextTestCase, EBinaryTest);
+			DeletePathAfterTest(*nextTestCase);
+			}
+
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken(0);
+		timeTaken = endTime.MicroSecondsFrom(startTime);
+
+//		test.Printf(_L("Test Case Id : %d\n"),(*nextTestCase).iTestCaseID);
+//		TInt time2=0;
+//		time2=I64LOW(timeTaken.Int64()/1000);
+//		test.Printf(_L("Time Taken by test id %d = %d mS \n"),nextTestCase.iTestCaseID,time2);
+		++i;
+		}
+
+	delete nextTestCase;
+	}
+
+/*
+ * Main testing control unit
+ */
+void TestMainWithDLLL(TTestSwitches& aSwitches)
+	{
+	// Enables codepage dll implementation of LocaleUtils functions for this test only
+	TInt r = TheFs.ControlIo(CurrentDrive(), KControlIoEnableFatUtilityFunctions);
+	test(r == KErrNone);
+		
+	test.Printf(_L("Load the Code Page DLL"));
+	r = UserSvr::ChangeLocale(KTestLocale);
+	test(r == KErrNone);
+			
+	test.Next(_L("Test Unitary APIs with only Sync Variant with DLL"));
+	gLogFailureData.iFuncName = KDoAllBasicUnitaryTestsL;
+	DoAllBasicUnitaryTestsL(gBasicUnitaryTestCases, aSwitches, ETrue);
+	
+	test.Next(_L("Test Binary Tests with DLL"));
+	gLogFailureData.iFuncName = KDoAllBasicBinaryTestsL;
+	DoAllBasicBinaryTestsL(gBasicBinaryTestCases, aSwitches, ETrue);
+	
+	// Disables codepage dll implementation of LocaleUtils functions for other base tests
+	r = TheFs.ControlIo(CurrentDrive(), KControlIoDisableFatUtilityFunctions);
+	test(r == KErrNone);
+	}
+	
+void TestMainWithoutDLLL(TTestSwitches& aSwitches)
+	{
+	test.Next(_L("Test Unitary APIs with only Sync Variant without DLL"));
+
+	// Disables codepage dll implementation of LocaleUtils functions
+	TInt r = TheFs.ControlIo(CurrentDrive(), KControlIoDisableFatUtilityFunctions);
+	test(r == KErrNone);
+
+	gLogFailureData.iFuncName = KDoAllBasicUnitaryTestsL;
+	DoAllBasicUnitaryTestsL(gBasicUnitaryTestCases, aSwitches, EFalse);
+	
+	test.Next(_L("Test Binary Tests without DLL"));
+	gLogFailureData.iFuncName = KDoAllBasicBinaryTestsL;
+	DoAllBasicBinaryTestsL(gBasicBinaryTestCases, aSwitches, EFalse);
+	}
+
+void TestCompatibility(const TTestSwitches& aSwitches)
+	{
+	test.Next(_L("test compatibility"));
+
+	// logging for failure
+	gTCType = ESymbianFATSpecific;
+	RBuf failedOnBuf;
+	failedOnBuf.CreateL(gLogFailureData.iFuncName);
+	gTCId = 0;
+	RBuf tcUniquePath;
+	tcUniquePath.CreateL(KNone());
+
+	// original file name in DBCS
+	TFileName fn1 = _L("\\\x798F\x5C71\x96C5\x6CBB");
+	if (aSwitches.iExeOnSymbian)
+		{
+		GetBootInfo();
+		RFile file;
+		TFileName fn = _L("\\ABCD");
+		
+		TInt r=file.Create(TheFs,fn,EFileRead);
+		testAndLog(r==KErrNone);
+		file.Close();
+
+		//	Assume this file is the first entry in the root directory
+		r=TheDisk.Open(TheFs,CurrentDrive());
+		testAndLog(r==KErrNone);
+		
+	    //-- read the 1st dir entry, it should be a DOS entry 
+	    const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position
+	    
+	    TFatDirEntry fatEntry1;
+		TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry));
+	    testAndLog(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone); 
+	    testAndLog(!fatEntry1.IsVFatEntry());
+
+	    // Manually modify the short name into unicode characters
+	    // 	Unicode: 	0x(798F 5C71 96C5 6CBB)
+	    //	Shift-JIS: 	0x(959F 8E52 89EB 8EA1)
+
+	    TBuf8<8> unicodeSN = _L8("ABCD1234");
+	    unicodeSN[0] = 0x95;
+	    unicodeSN[1] = 0x9F;
+	    unicodeSN[2] = 0x8E;
+	    unicodeSN[3] = 0x52;
+	    unicodeSN[4] = 0x89;
+	    unicodeSN[5] = 0xEB;
+	    unicodeSN[6] = 0x8E;
+	    unicodeSN[7] = 0xA1;
+	    
+	    fatEntry1.SetName(unicodeSN);
+	    testAndLog(TheDisk.Write(posEntry1, ptrEntry1)==KErrNone);
+	    TheDisk.Close();
+		}
+	if (aSwitches.iVerOnSymbian)
+		{
+		// Access the file without the DLL loaded.
+	    TInt r = TheFs.ControlIo(CurrentDrive(), KControlIoDisableFatUtilityFunctions);
+		testAndLog(r==KErrNone);
+		
+		TEntry entry;
+		r = TheFs.Entry(fn1, entry);
+		testAndLog(r==KErrNotFound);
+		
+	    // Access the file with the DLL loaded.
+	    r = TheFs.ControlIo(CurrentDrive(), KControlIoEnableFatUtilityFunctions);
+		testAndLog(r==KErrNone);
+		r = UserSvr::ChangeLocale(KTestLocale);
+		testAndLog(r==KErrNone);
+
+		r = TheFs.Entry(fn1, entry);
+		testAndLog(r==KErrNone);
+		
+	    r = TheFs.ControlIo(CurrentDrive(), KControlIoDisableFatUtilityFunctions);
+		testAndLog(r==KErrNone);
+		}
+	failedOnBuf.Close();
+	tcUniquePath.Close();
+	}
+
+#endif //defined(_DEBUG) || defined(_DEBUG_RELEASE)
+
+/*
+ * Initialise test 
+*/
+void CallTestsL(TTestSwitches& aSwitches)
+	{
+	test.Title();
+	test.Start(_L("Starting T_FATCHARSETCONV tests"));
+	(void) aSwitches;
+#ifdef LOG_FAILURE_DATA
+	test.Printf(_L("LOG_FAILURE_DATA: ON\n"));
+#else
+	test.Printf(_L("LOG_FAILURE_DATA: OFF\n"));
+#endif
+
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+	// Test only runs on Fat file systems
+	TheFs.SessionPath(gSessionPath);
+	TInt r = TheFs.FileSystemName(aSwitches.iMountedFSName, CurrentDrive());
+	if (KErrNone == r)
+		{
+		// For automated testing this test should run on FAT file systems only.
+		// For inter-operability testing on FAT and Win32 file systems.
+		// if ((AUTO && FAT) || (IOT && (FAT || Win32))
+		test.Printf(_L("Current File System: \"%S\"\n"), &aSwitches.iMountedFSName);
+		if( (gAutoTest && isFAT(aSwitches.iMountedFSName)) ||
+			(gIOTesting && (isFAT(aSwitches.iMountedFSName) || isWin32(aSwitches.iMountedFSName))))
+			{
+			// Log File System Name
+			gLogFailureData.iFSName = aSwitches.iMountedFSName;
+			
+			// Store current file name
+			TFileName fileName;
+			TInt i=0;
+			while(__FILE__[i]!='\0')
+				{
+				fileName.SetLength(i+1);
+				fileName[i] = __FILE__[i++];
+				}
+			gFileName.Append(fileName);
+			
+			InitialiseL();
+			// Special Cases	- Non-Symbian
+			// Note: this case MUST be run as the first case as it performs formatting!!
+			TestCompatibility(aSwitches);
+			CreateTestDirectory(_L("\\F32-TST\\T_FATCHARSETCONV\\"));
+			//Special Cases	- Only Symbian Specific
+			if(!gIOTesting && aSwitches.iMountedFSName.Compare(KFAT) == 0)
+				{
+				DoSymbianSpecificCases();
+				}
+
+			test.Next(_L("Test without DLL loaded"));
+			if(gAutoTest)
+				{
+				QuickFormat();
+				}
+			TestMainWithoutDLLL(aSwitches);
+							
+			test.Next(_L("Test with DLL loaded"));
+			if(gAutoTest)
+				{
+				QuickFormat();
+				}
+			TestMainWithDLLL(aSwitches);
+			Cleanup();
+			}
+		else
+			{
+			if(gAutoTest)
+				test.Printf(_L("Test only runs on \"FAT\" File Systems !!!\n"));
+			if(gIOTesting)
+				test.Printf(_L("Test only runs on \"FAT\" and \"Win32\" File Systems !!!\n"));
+			}
+		}
+	else
+		{
+		test.Printf(_L("Drive %C: is not ready!\n"), 'A'+CurrentDrive());
+		test(EFalse);
+		}
+#else
+	test.Printf(_L("Test only runs on DEBUG builds, see test logs of debug builds for details.\n"));
+#endif  // _DEBUG) || _DEBUG_RELEASE
+	test.End();
+	}
+
+LOCAL_C void PushLotsL()
+//
+// Expand the cleanup stack
+//
+	{
+	TInt i;
+	for(i=0;i<1000;i++)
+		CleanupStack::PushL((CBase*)NULL);
+	CleanupStack::Pop(1000);
+	}
+
+
+LOCAL_C void DoTests(TInt aDrive, TTestSwitches& aSwitches)
+//
+// Do testing on aDrive
+//
+	{
+	gSessionPath=_L("?:\\F32-TST\\");
+	TChar driveLetter;
+	TInt r=TheFs.DriveToChar(aDrive,driveLetter);
+	test(r==KErrNone);
+	gSessionPath[0]=(TText)driveLetter;
+	r=TheFs.SetSessionPath(gSessionPath);
+	test(r==KErrNone);
+	test.Printf(_L("gSessionPath = \"%S\"\n"), &gSessionPath);
+
+// !!! Disable platform security tests until we get the new APIs
+//	if(User::Capability() & KCapabilityRoot)
+		CheckMountLFFS(TheFs,driveLetter);
+	
+	User::After(1000000);
+
+//	Format(CurrentDrive());
+
+	r=TheFs.MkDirAll(gSessionPath);
+	if(r == KErrCorrupt)
+		{
+		Format(aDrive);
+		r=TheFs.MkDirAll(gSessionPath);
+		test(r==KErrNone);
+		}
+	if (r!=KErrNone && r!=KErrAlreadyExists)
+		{
+		test.Printf(_L("MkDirAll() r %d\n"),r);
+		test(EFalse);
+		}
+	TheFs.ResourceCountMarkStart();
+	TRAP(r,CallTestsL(aSwitches));
+	if (r==KErrNone)
+		TheFs.ResourceCountMarkEnd();
+	else
+		{
+		test.Printf(_L("Error: Leave %d\n"),r);
+		test(EFalse);
+		}
+
+	CheckDisk();
+	TestingLFFS(EFalse);
+	}
+
+	
+GLDEF_C TInt E32Main()
+//
+// Test with drive nearly full
+//
+    {
+	CTrapCleanup* cleanup;
+	cleanup=CTrapCleanup::New();
+	TRAPD(r,PushLotsL());
+	__UHEAP_MARK;
+
+	test.Title();
+	test.Start(_L("Starting tests..."));
+
+	gSessionPath=_L("?:\\F32-TST\\");
+	TTestSwitches testSwitches;
+	ParseCommandArguments(testSwitches);
+
+	r=TheFs.Connect();
+	test(r==KErrNone);
+	TheFs.SetAllocFailure(gAllocFailOn);
+
+	TTime timerC;
+	timerC.HomeTime();
+
+	TInt theDrive;
+	r=TheFs.CharToDrive(gDriveToTest,theDrive);
+	test(r==KErrNone);
+	
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+	TPckgBuf<TIOCacheValues> pkgOrgValues;
+	TIOCacheValues& orgValues=pkgOrgValues();
+	r = controlIo(TheFs,theDrive, KControlIoCacheCount, orgValues);
+	test(r==KErrNone);
+
+	test.Printf(_L("\n"));
+	test.Printf(_L("Requests on close queue at start=%d\n"),orgValues.iCloseCount);
+	test.Printf(_L("Requests on free queue at start=%d\n"),orgValues.iFreeCount);
+	test.Printf(_L("Requests dynamically allocated at start=%d\n"),orgValues.iAllocated);
+	test.Printf(_L("Requests in total at start=%d\n"),orgValues.iTotalCount);
+#endif
+
+	DoTests(theDrive, testSwitches);
+
+	TTime endTimeC;
+	endTimeC.HomeTime();
+	TTimeIntervalSeconds timeTakenC;
+	r=endTimeC.SecondsFrom(timerC,timeTakenC);
+	test(r==KErrNone);
+
+	test.Printf(_L("Time taken for test = %d seconds\n"),timeTakenC.Int());
+	TheFs.SetAllocFailure(gAllocFailOff);
+	
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+	TPckgBuf<TIOCacheValues> pkgValues;
+	TIOCacheValues& values=pkgValues();
+	r = controlIo(TheFs,theDrive, KControlIoCacheCount, values);
+	test(r==KErrNone);
+	
+	test.Printf(_L("Requests on close queue at end=%d\n"),values.iCloseCount);
+	test.Printf(_L("Requests on free queue at end=%d\n"),values.iFreeCount);
+	test.Printf(_L("Requests dynamically allocated at end=%d\n"),values.iAllocated);
+	test.Printf(_L("Requests in total at end=%d\n"),values.iTotalCount);
+	
+	test(orgValues.iCloseCount==values.iCloseCount);
+	test(orgValues.iAllocated == values.iAllocated);
+#endif
+
+	TheFs.Close();
+	test.End();
+	test.Close();
+	__UHEAP_MARKEND;
+	delete cleanup;
+	return(KErrNone);
+    }