--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_dirs.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,957 @@
+// Copyright (c) 1995-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_dirs.cpp
+// 
+//
+
+#include <f32file.h>
+#include <e32test.h>
+#include "t_server.h"
+
+#include "f32_test_utils.h"
+
+using namespace F32_Test_Utils;
+
+
+RTest test(_L("T_DIRS"));
+
+TTime gTimeNow;
+TBool gTestedZ = EFalse;
+TInt gDriveNum = -1;
+
+static void Test1()
+//
+// Make a directory with lots of entries
+//
+	{
+
+	RFile f;
+	TInt maxEntry=56;
+	test.Next(_L("Create a directory with 55 entries"));
+	TFileName sessionPath;
+	TInt r=TheFs.SessionPath(sessionPath);
+	test(r==KErrNone);
+	r=TheFs.MkDir(_L("\\F32-TST\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	
+	for (TInt i=0;i<maxEntry;i++)
+		{
+		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
+		baseName.AppendNum(i);
+		r=f.Replace(TheFs,baseName,EFileRead);
+		test(r==KErrNone);
+		r=f.Write(_L8("Hello World"));
+		test(r==KErrNone);
+		f.Close();
+		}
+	test.Next(_L("Test all entries have been created successfully."));
+	for (TInt j=0;j<=maxEntry;j++)
+		{
+		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
+		baseName.AppendNum(j);
+		TInt r=f.Open(TheFs,baseName,EFileRead);
+		if (r!=KErrNone)
+			{
+			test(r==KErrNotFound && j==maxEntry);
+			return;
+			}
+		TBuf8<16> data;
+		r=f.Read(data);
+		test(r==KErrNone);
+		test(data==_L8("Hello World"));
+		f.Close();
+		}
+	}
+	
+static void Test2()
+//
+// List all directory entries
+//
+	{
+	
+	test.Printf(_L("List all entries in directory %S\n"),&gSessionPath);
+	RDir d;
+
+	TInt r=d.Open(TheFs,gSessionPath,KEntryAttMaskSupported);
+	if (r==KErrNone)
+		{
+		TEntry e;
+		while ((r=d.Read(e))==KErrNone)
+			{
+			if (e.IsDir())
+				test.Printf(_L("%- 20S <DIR>\n"),&e.iName);
+			else
+				test.Printf(_L("%- 20S %+ 8d\n"),&e.iName,e.iSize);
+			}
+		d.Close();
+		if (r!=KErrEof)
+			test.Printf(_L("Error %d\n"),r);
+		}
+	else
+		test.Printf(_L("Error %d\n"),r);	
+	}
+
+static void TestZ()
+//
+// Check you cannot open a directory on a file
+//
+	{
+
+	test.Next(_L("Open files and directories on Z:"));
+	TEntry entry;
+	RDir d;
+	
+	TInt r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE\\*"):_L("\\System\\Bin\\ESHELL.EXE\\*"),KEntryAttMaskSupported);
+	test(r==KErrPathNotFound);
+	
+	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE"):_L("\\System\\Bin\\ESHELL.EXE"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	
+	r=d.Read(entry);
+	if (r==KErrEof)
+		{
+		test.Printf(_L("Error: EShell.EXE not found\n"));
+		//test.Getch();
+		}
+	else
+		{
+		test(r==KErrNone);
+		test(entry.iName.FindF(_L("ESHELL.EXE"))>=0);
+		r=d.Read(entry);
+		test(r==KErrEof);
+		}
+	d.Close();
+
+	r=d.Open(TheFs,_L("\\*.XQP"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	r=d.Read(entry);
+	test(r==KErrEof);
+	d.Close();
+
+	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\"):_L("\\System\\Bin\\"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	r=d.Read(entry);
+	
+	if (r==KErrEof)
+		{
+		test.Printf(_L("No files found\n"));
+		d.Close();
+		}
+	else
+		{
+		test(r==KErrNone);
+		test.Printf(_L("First Entry = %S\n"),&entry.iName);
+		r=d.Read(entry);
+		test(r==KErrNone);
+		test.Printf(_L("Second Entry = %S\n"),&entry.iName);
+		d.Close();
+		}
+
+	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\*"):_L("\\System\\Bin\\*"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	}
+
+static void Test3()
+//
+// Check you cannot open a directory on a file
+//
+	{
+
+	test.Next(_L("Open files and directories"));
+	TEntry entry;
+	RFile f;
+	TInt r=f.Replace(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),EFileWrite);
+	test(r==KErrNone);
+	r=f.Write(_L8("TESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATA"));
+	test(r==KErrNone);
+	r=TheFs.Delete(_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"));
+	test(r==KErrInUse);
+	f.Close();
+	RDir d;
+	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR\\*"),KEntryAttMaskSupported);
+	test(r==KErrPathNotFound);
+	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\*.XQP"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	r=d.Read(entry);
+	test(r==KErrEof);
+	d.Close();
+	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	r=d.Read(entry);
+	test(r==KErrNone);
+	test(entry.iName.FindF(_L("TESTFILEORISITA.DIR"))>=0);
+	r=d.Read(entry);
+	test(r==KErrEof);
+	d.Close();
+	r=d.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	r=d.Open(TheFs,_L("\\F32-TST\\"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	r=d.Open(TheFs,_L("\\F32-TST\\*"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	d.Close();
+	
+	// create a small file on the root
+	test(f.Replace(TheFs, _L("\\TEST.FILE"), EFileWrite) == KErrNone);
+	test(f.Write(_L8("1234567890987654321234567890")) == KErrNone);
+	f.Close();
+	// try some directory operations on the file
+	test(TheFs.RmDir(_L("\\TEST.FILE\\")) == KErrPathNotFound);
+	test(TheFs.RmDir(_L("\\TEST.FILE\\ZZZ\\")) == KErrPathNotFound);
+	test(TheFs.MkDir(_L("\\TEST.FILE\\ZZZ\\")) == KErrPathNotFound);
+	// cleanup
+	TheFs.Delete(_L("\\TEST.FILE"));	
+	
+	
+	r=TheFs.MkDir(_L("\\F32-TST\\EMPTY\\"));
+	test(r==KErrNone || r==KErrAlreadyExists);
+	r=d.Open(TheFs,_L("\\F32-TST\\EMPTY\\*"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+//	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
+	r=d.Read(entry);
+	test(r==KErrEof);
+//	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
+//	test(r==KErrInUse);
+	r=d.Read(entry);
+	r=d.Read(entry);
+	r=d.Read(entry);
+	d.Close();
+	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
+	test(r==KErrNone);
+	}
+
+
+static void CreateSortNoneTestDirectoryStructure()
+//
+// Create files
+//
+	{
+//	Delete the directory to be tested if it already exists as a result of this
+//	test being run previously.  It's necessary remove it and then recreate it 
+//	because a later test relies on the time of file/directory creation to be
+//	the time this function was run...
+	
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	TInt r=fMan->RmDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
+	test((r==KErrNone)||(r==KErrPathNotFound));
+	delete fMan;	
+
+	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
+	r=TheFs.MkDirAll(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
+	test(r==KErrNone || r==KErrAlreadyExists);
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.txt"));
+	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR1.APP\\"));
+	test(r==KErrNone || r==KErrAlreadyExists);
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.app"));
+	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR2.TXT\\"));
+	test(r==KErrNone || r==KErrAlreadyExists);
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.txt"));
+	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR3.APP\\"));
+	test(r==KErrNone || r==KErrAlreadyExists);
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\ZZZZ"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\AAAA"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\WWWW"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.app"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.txt"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.app"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\NOEXT1"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\NOEXT2"));
+	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\EXTMISSING"));
+	}
+
+static void Test4()
+//
+// Test ESortNone
+//
+	{
+
+	test.Next(_L("Test ESortNone"));
+	CreateSortNoneTestDirectoryStructure();
+	CDir* dir;
+	CDir* dirSorted;
+	
+//
+// GetDir OOM failure passes 'callback' test from client side but not server side
+//
+	TheFs.SetAllocFailure(gAllocFailOff);
+
+	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortNone,dir);
+	test(r==KErrNone);
+	TInt count=dir->Count();
+	test(count==15);
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortByName,dirSorted);
+	test(r==KErrNone);
+	test(dirSorted->Count()==15);
+	delete dirSorted;
+	delete dir;
+
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.txt"),KEntryAttNormal,ESortNone,dir);
+	test(r==KErrNone);
+	test(dir->Count()==3);
+	delete dir;
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal,ESortNone,dir);
+	test(r==KErrNone);
+	test(dir->Count()==3);
+	delete dir;
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone,dir);
+	test(r==KErrNone);
+	test(dir->Count()==5);
+	delete dir;
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsFirst,dir);
+	test(r==KErrNone);
+	test(dir->Count()==5);
+	delete dir;
+	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsLast,dir);
+	test(r==KErrNone);
+	test(dir->Count()==5);
+	delete dir;
+
+	TheFs.SetAllocFailure(gAllocFailOn);
+	}
+
+static void Test5()
+//
+// Test return values
+//
+	{
+
+	test.Next(_L("Test return values"));
+	RDir dir;
+	TInt r=dir.Open(TheFs,_L("\\DoesNotExist\\*"),KEntryAttMaskSupported);
+	test(r==KErrPathNotFound);
+	r=dir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
+	test(r==KErrNone);
+	dir.Close();
+	}
+
+
+static void Test6()
+//
+// Test that "*.*" matches all files/directories
+//
+	{
+
+	test.Next(_L("Test *.* matches all files"));
+	CDir* dirList;
+	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir,ESortByName|EDirsLast,dirList);
+	test(r==KErrNone);
+	TInt count=dirList->Count();
+	test(count==15);
+	TEntry entry=(*dirList)[0];
+	test(entry.iName.FindF(_L("AAAA"))>=0);
+	entry=(*dirList)[1];
+	test(entry.iName.FindF(_L("EXTMISSING"))>=0);
+	entry=(*dirList)[2];
+	test(entry.iName.FindF(_L("FILE1.APP"))>=0);
+	entry=(*dirList)[3];
+	test(entry.iName.FindF(_L("FILE1.TXT"))>=0);
+	entry=(*dirList)[4];
+	test(entry.iName.FindF(_L("FILE2.APP"))>=0);
+	entry=(*dirList)[5];
+	test(entry.iName.FindF(_L("FILE2.TXT"))>=0);
+	entry=(*dirList)[6];
+	test(entry.iName.FindF(_L("FILE3.APP"))>=0);
+	entry=(*dirList)[7];
+	test(entry.iName.FindF(_L("FILE3.TXT"))>=0);
+	entry=(*dirList)[8];
+	test(entry.iName.FindF(_L("NOEXT1"))>=0);
+	entry=(*dirList)[9];
+	test(entry.iName.FindF(_L("NOEXT2"))>=0);
+	entry=(*dirList)[10];
+	test(entry.iName.FindF(_L("WWWW"))>=0);
+	entry=(*dirList)[11];
+	test(entry.iName.FindF(_L("ZZZZ"))>=0);
+	entry=(*dirList)[12];
+	test(entry.iName.FindF(_L("FILE_DIR1.APP"))>=0);
+	entry=(*dirList)[13];
+	test(entry.iName.FindF(_L("FILE_DIR2.TXT"))>=0);
+	entry=(*dirList)[14];
+	test(entry.iName.FindF(_L("FILE_DIR3.APP"))>=0);
+	delete dirList;
+
+	RDir dir;
+	r=dir.Open(TheFs,_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir);
+	test(r==KErrNone);
+	
+	TTime time;
+	TInt64 difference;
+	TInt64 maxOK=1000000;
+	maxOK*=60;
+	maxOK*=3;
+
+	for (TInt i=0; i<15; i++)
+		{
+		r=dir.Read(entry);
+		test(r==KErrNone);
+		time=entry.iModified;
+		difference=time.Int64()-gTimeNow.Int64();
+		test(difference<maxOK);
+		}
+
+	r=dir.Read(entry);
+	test(r==KErrEof);
+	dir.Close();
+
+	TheFs.SetAllocFailure(gAllocFailOn);
+	}
+
+
+static void Test7()
+//
+// Fill up the root directory
+//
+	{
+    test.Next(_L("Fill up the root directory"));
+    
+    if(!Is_Fat12(TheFs, gDriveNum) && !Is_Fat16(TheFs, gDriveNum))
+        {
+        test.Printf(_L("Skipping. Applicable for FAT12/16 only!\n"));
+        return;
+        }    
+
+    TInt r = FormatDrive(TheFs, gDriveNum, ETrue);
+    test(r==KErrNone);
+
+	TBuf<32> baseName=_L("\\RD");
+	TBuf<32> id;
+	TBuf<32> fileName;
+	TInt count=0;
+
+	RFile f;
+	TParsePtrC parser(gSessionPath);
+	FOREVER
+		{
+		id.Num(count+1);
+		fileName=parser.Drive();
+		fileName+=baseName;
+		fileName+=id;
+		TInt r=f.Replace(TheFs,fileName,EFileWrite);
+		if(r==KErrDirFull)
+			{
+			break;
+			}
+		test(r==KErrNone);
+		f.Close();
+		count++;
+		if(count >= 1000)
+			{
+			break;
+			}
+		test.Printf(_L("CreateFile	:	%d	: %S\r"),count,&fileName);
+		}
+	test.Printf(_L("\n"));
+
+	while (count)
+		{
+		id.Num(count);
+		fileName=parser.Drive();
+		fileName+=baseName;
+		fileName+=id;
+		TInt r=TheFs.Delete(fileName);
+		test(r==KErrNone);
+		test.Printf(_L("DeleteFile	:	%d	: %S\r"),count,&fileName);
+		--count;
+		}
+	test.Printf(_L("\n"));
+
+	test.Next(_L("Long filenames in root"));
+	TFileName longFileName;
+	longFileName.SetLength(254);
+//	Mem::Fill((TUint8*)longFileName.Ptr(),254,'A');
+	Mem::Fill((TUint8*)longFileName.Ptr(),254*sizeof(TText),'A');
+	longFileName[0]='\\';
+	longFileName[253]='\\';
+	r=TheFs.MkDir(longFileName);
+	test(r==KErrNone);
+	CDir* dirList=NULL;
+	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
+	test(r==KErrNone);
+	count=dirList->Count();
+	test(count==0);
+	delete dirList;
+	TParse parse;
+	r=TheFs.Parse(longFileName,parse);
+	test(r==KErrNone);
+	TEntry entry;
+	r=TheFs.Entry(longFileName,entry);
+	test(r==KErrNone);
+	r=TheFs.SetSessionPath(longFileName);
+	test(r==KErrNone);
+	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
+	test(r==KErrNone);
+	count=dirList->Count();
+	test(count==0);
+	delete dirList;
+	r=TheFs.Parse(longFileName,_L("*"),parse);
+	test(r==KErrBadName);
+	r=f.Open(TheFs,_L("asdf.asdf"),0);
+	test(r==KErrBadName);
+	r=TheFs.Entry(longFileName,entry);
+	test(r==KErrNone);
+	r=TheFs.RmDir(longFileName);
+	test(r==KErrNone);
+	}
+
+static void Test8()
+//
+// Regression tests
+//
+	{
+
+	test.Next(_L("Open dir and change drives"));
+	MakeDir(_L("C:\\MOON\\"));
+	RDir dir;
+	TInt r=dir.Open(TheFs,_L("C:\\MOON\\"),0);
+	test(r==KErrNone);
+	TFileName driveName;
+	r=TheFs.GetDriveName(11,driveName);
+	test(r==KErrNone);
+	TEntryArray entryArray;
+	r=dir.Read(entryArray);
+	test(r==KErrEof);
+	test(entryArray.Count()==0);
+	dir.Close();
+	r=TheFs.RmDir(_L("C:\\MOON\\"));
+	test(r==KErrNone);
+
+	test.Next(_L("MkDir all on nonexistent drive"));
+	r=TheFs.MkDirAll(_L("L:\\MOON"));
+	test((r==KErrNotReady)||(r==KErrPathNotFound));
+	}
+
+static void CleanupL()
+//
+// Clean up tests
+//
+	{
+
+	test.Next(_L("Delete test directory"));
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	TInt r=fMan->RmDir(gSessionPath);
+	test(r==KErrNone);
+	r=fMan->Delete(_L("\\Filluptherootdir*"));
+	test(r==KErrNone || r==KErrNotFound);
+	delete fMan;
+	}
+
+static void Test9()
+//
+// Test directories with trailing dots (ref. DEF047684) 
+//
+	{
+
+	test.Next(_L("Testing directory names with trailing dots"));
+	TInt r;
+	r=TheFs.MkDir(_L("\\test9..\\"));
+	test(r==KErrBadName);
+	r=TheFs.MkDir(_L("\\test9\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	r=TheFs.Rename(_L("\\test9\\"),_L("\\test9..\\"));
+	test(r==KErrBadName);
+	r= TheFs.RmDir(_L("\\test9\\"));
+	test((r==KErrNone));
+	r=TheFs.MkDir(_L("\\t.\\"));
+	test(r==KErrBadName);
+	}
+
+
+//
+// Path and File names for sorting by name
+//
+// The correctly sorted directory listing should be:
+//
+//     b.doc
+//     bb.doc
+//     bs.doc
+//
+_LIT(KSortByNamePath, "\\F32-TST\\TDIRS\\SORT_NAME\\");
+_LIT(KFileBS,         "bs.doc");
+_LIT(KFileBB,         "bb.doc");
+_LIT(KFileB,          "b.doc");
+_LIT(KSortAll,        "*.*");
+_LIT(KPrintFileName,  "%S\n");
+
+
+static void DeleteTestDirectoryStructure(const TDesC& aPath)
+//
+//	Delete the directory to be tested if it already exists as a result of this
+//	test being run previously.
+//
+	{
+	
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	test(fMan!=NULL);
+	TInt r=fMan->RmDir(aPath);
+	test((r==KErrNone)||(r==KErrPathNotFound));
+	delete fMan;	
+	}
+
+
+static void CreateTestDirectoryStructure(const TDesC& aPath, const TDesC** aFileArray, TInt aNumFiles)
+//
+// Create files
+//
+	{
+	DeleteTestDirectoryStructure(aPath);	
+
+	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
+	TInt r=TheFs.MkDirAll(aPath);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	TBuf<128> fileName;
+	for (TInt i = 0; i < aNumFiles; i++)
+		{
+		fileName = aPath;
+		fileName.Append(*aFileArray[i]);
+		MakeFile(fileName);
+		}
+	}
+
+
+static void TestSortByName()
+//
+// Test that sorting by name works for different length filenames.
+//
+	{
+	const TDesC* theFiles[] = {&KFileBS, &KFileBB, &KFileB};
+	TInt numFiles = sizeof(theFiles)/sizeof(theFiles[0]);
+	CreateTestDirectoryStructure(KSortByNamePath, theFiles, numFiles);
+
+	test.Next(_L("Test ESortByName"));
+	CDir* dirList;
+	TBuf<128> sortSpec(KSortByNamePath);
+	sortSpec.Append(KSortAll);
+	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast, dirList);
+	test(r==KErrNone);
+	TInt count=dirList->Count();
+	test(count==numFiles);
+
+
+	TInt i;
+	for (i = 0; i < count; i++)
+		{
+		test.Printf(KPrintFileName, &(*dirList)[i].iName);
+		}
+	
+	TEntry entry=(*dirList)[0];
+	test(entry.iName.FindF(KFileB)>=0);
+	entry=(*dirList)[1];
+	test(entry.iName.FindF(KFileBB)>=0);
+	entry=(*dirList)[2];
+	test(entry.iName.FindF(KFileBS)>=0);
+	delete dirList;
+	dirList = 0;
+
+
+	test.Next(_L("Test ESortByName (descending)"));
+
+
+	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast | EDescending, dirList);
+	test(r==KErrNone);
+	count=dirList->Count();
+	test(count==numFiles);
+
+
+	for (i = 0; i < count; i++)
+		{
+		test.Printf(KPrintFileName, &(*dirList)[i].iName);
+		}
+
+	
+	entry=(*dirList)[0];
+	test(entry.iName.FindF(KFileBS)>=0);
+	entry=(*dirList)[1];
+	test(entry.iName.FindF(KFileBB)>=0);
+	entry=(*dirList)[2];
+	test(entry.iName.FindF(KFileB)>=0);
+	delete dirList;
+	dirList = 0;
+	
+	
+	DeleteTestDirectoryStructure(KSortByNamePath);
+	}
+
+
+
+//
+// Path and File names for sorting by extension
+//
+// The correctly sorted directory listing should be:
+//
+//     sortext.a
+//     sortext.bbb.a
+//     sortext1.ddd.a
+//     sortext.aaa.b
+//     sortext.b
+//     sortext.c
+//     sortext.ccc.c
+//
+// as we should sort by the substring after the last '.'
+//
+_LIT(KSortByExtPath, "\\F32-TST\\TDIRS\\SORT_EXT\\");
+_LIT(KFile1,         "sortext.aaa.b");
+_LIT(KFile2,         "sortext.bbb.a");
+_LIT(KFile3,         "sortext.ccc.c");
+_LIT(KFile4,         "sortext1.ddd.a");
+_LIT(KFile5,         "sortext.a");
+_LIT(KFile6,         "sortext.b");
+_LIT(KFile7,         "sortext.c");
+
+
+static void TestSortByExt()
+//
+// Test that sorting by extension works. This includes filenames
+// that contain multiple .'s
+//
+	{
+	const TDesC* theFiles[] = {&KFile1, &KFile2, &KFile3, &KFile4, &KFile5, &KFile6, &KFile7};
+	TInt numFiles = sizeof(theFiles)/sizeof(theFiles[0]);
+	CreateTestDirectoryStructure(KSortByExtPath, theFiles, numFiles);
+
+	test.Next(_L("Test ESortByExt"));
+
+	CDir* dirList;
+	TBuf<128> sortSpec(KSortByExtPath);
+	sortSpec.Append(KSortAll);
+	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast, dirList);
+	test(r==KErrNone);
+	TInt count=dirList->Count();
+	test(count==numFiles);
+
+
+	TInt i;
+	for (i = 0; i < count; i++)
+		{
+		test.Printf(KPrintFileName, &(*dirList)[i].iName);
+		}
+	
+	
+	//
+	// Verify that the files have been sorted correctly by extension
+	//
+	TEntry entry=(*dirList)[0];
+	test(entry.iName.FindF(KFile5)>=0);
+	entry=(*dirList)[1];
+	test(entry.iName.FindF(KFile2)>=0);
+	entry=(*dirList)[2];
+	test(entry.iName.FindF(KFile4)>=0);
+	entry=(*dirList)[3];
+	test(entry.iName.FindF(KFile1)>=0);
+	entry=(*dirList)[4];
+	test(entry.iName.FindF(KFile6)>=0);
+	entry=(*dirList)[5];
+	test(entry.iName.FindF(KFile7)>=0);
+	entry=(*dirList)[6];
+	test(entry.iName.FindF(KFile3)>=0);
+	delete dirList;
+	dirList = 0;
+
+
+	test.Next(_L("Test ESortByExt (descending)"));
+
+	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast | EDescending, dirList);
+	test(r==KErrNone);
+	count=dirList->Count();
+	test(count==numFiles);
+
+
+	for (i = 0; i < count; i++)
+		{
+		test.Printf(KPrintFileName, &(*dirList)[i].iName);
+		}
+	
+	
+	//
+	// Verify that the files have been sorted correctly by extension
+	// Note that this listing should be the reverse of that above.
+	//
+	entry=(*dirList)[0];
+	test(entry.iName.FindF(KFile3)>=0);
+	entry=(*dirList)[1];
+	test(entry.iName.FindF(KFile7)>=0);
+	entry=(*dirList)[2];
+	test(entry.iName.FindF(KFile6)>=0);
+	entry=(*dirList)[3];
+	test(entry.iName.FindF(KFile1)>=0);
+	entry=(*dirList)[4];
+	test(entry.iName.FindF(KFile4)>=0);
+	entry=(*dirList)[5];
+	test(entry.iName.FindF(KFile2)>=0);
+	entry=(*dirList)[6];
+	test(entry.iName.FindF(KFile5)>=0);
+	delete dirList;
+	dirList = 0;
+
+	
+	DeleteTestDirectoryStructure(KSortByExtPath);
+	}
+
+//--------------------------------------------- 
+//! @SYMTestCaseID			PBASE-T_DIRS-1310
+//! @SYMTestType			CT 
+//! @SYMREQ					DEF125143
+//! @SYMTestCaseDesc		Test that directory name is handled by File Server interfaces properly.
+//! @SYMTestActions			Uses RFs::IsValidName(), RFs::MkDir(), RDir::Open(), RFs::RmDir() to test
+//!							various dir name handling.
+//! @SYMTestExpectedResults	Proper error code is returned.
+//! @SYMTestPriority		High
+//! @SYMTestStatus			Implemented 
+//--------------------------------------------- 	
+void TestDirNameHandling()
+	{	
+	test.Next(_L("Test Dir Name Handling Interfaces"));
+	TFileName dirTest1;
+	dirTest1 = _L("\\F32-TST\\TDIRS\\test1\\FILE.TXT");
+	TFileName dirTest2;
+	dirTest2 = _L("\\F32-TST\\TDIRS\\test2.\\FILE.TXT");
+	TFileName dirTest3;
+	dirTest3 = _L("\\F32-TST\\TDIRS\\test3. \\FILE.TXT");
+	TFileName dirTest4;
+	dirTest4 = _L("\\F32-TST\\TDIRS\\test4. . \\FILE.TXT");
+	TFileName dirTest5;
+	dirTest5 = _L("\\F32-TST\\TDIRS\\test5.\\FILE.TXT");
+	TFileName dirTest6;
+	dirTest6 = _L("\\F32-TST\\TDIRS\\test6. .\\FILE.TXT");
+
+    TBool valid = TheFs.IsValidName( dirTest1 );
+    test(valid);
+    valid = TheFs.IsValidName( dirTest2 );
+    test(!valid);
+    valid = TheFs.IsValidName( dirTest3 );
+    test(!valid);
+    valid = TheFs.IsValidName( dirTest4 );
+    test(!valid);
+    valid = TheFs.IsValidName( dirTest5 );
+    test(!valid);
+    valid = TheFs.IsValidName( dirTest6 );
+    test(!valid);
+
+	dirTest1 = _L("\\F32-TST\\TDIRS\\test1\\");
+	dirTest2 = _L("\\F32-TST\\TDIRS\\test2.\\");
+	dirTest3 = _L("\\F32-TST\\TDIRS\\test3. \\");
+	dirTest4 = _L("\\F32-TST\\TDIRS\\test4. . \\");
+	dirTest5 = _L("\\F32-TST\\TDIRS\\test5.\\");
+	dirTest6 = _L("\\F32-TST\\TDIRS\\test6. .\\");
+
+    TInt err = TheFs.MkDir(dirTest1);
+    test(err == KErrNone);
+    err = TheFs.MkDir(dirTest2);
+    test(err == KErrBadName);
+    err = TheFs.MkDir(dirTest3);
+    test(err == KErrBadName);
+    err = TheFs.MkDir(dirTest4);
+    test(err == KErrBadName);
+    err = TheFs.MkDir(dirTest5);
+    test(err == KErrBadName);
+    err = TheFs.MkDir(dirTest6);
+    test(err == KErrBadName);
+
+    RDir rdir;
+    err = rdir.Open(TheFs, dirTest1, 0);
+    rdir.Close();
+    test(err == KErrNone);
+
+    err = rdir.Open(TheFs, dirTest2, 0);
+    rdir.Close();
+    test(err == KErrBadName);
+
+    err = rdir.Open(TheFs, dirTest3, 0);
+    rdir.Close();
+    test(err == KErrBadName);
+
+    err = rdir.Open(TheFs, dirTest4, 0);
+    rdir.Close();
+    test(err == KErrBadName);
+
+    err = rdir.Open(TheFs, dirTest5, 0);
+    rdir.Close();
+    test(err == KErrBadName);
+
+    err = rdir.Open(TheFs, dirTest6, 0);
+    rdir.Close();
+    test(err == KErrBadName);
+
+    err = TheFs.RmDir(dirTest1);
+    test(err == KErrNone);
+    err = TheFs.RmDir(dirTest2);
+    test(err == KErrBadName);
+    err = TheFs.RmDir(dirTest3);
+    test(err == KErrBadName);
+    err = TheFs.RmDir(dirTest4);
+    test(err == KErrBadName);
+    err = TheFs.RmDir(dirTest5);
+    test(err == KErrBadName);
+    err = TheFs.RmDir(dirTest6);
+    test(err == KErrBadName);
+	}
+
+void CallTestsL()
+//
+// Do all tests
+//
+	{
+
+    //-- set up console output 
+    F32_Test_Utils::SetConsole(test.Console()); 
+    
+    TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
+    test(nRes==KErrNone);
+    
+    PrintDrvInfo(TheFs, gDriveNum);
+
+	TurnAllocFailureOff();
+	CreateTestDirectory(_L("\\F32-TST\\TDIRS\\"));
+	
+	if (!gTestedZ)
+		{
+		TInt r=TheFs.SetSessionPath(_L("Z:\\"));
+		test(r==KErrNone);
+		Test2();
+		TestZ();
+		r=TheFs.SetSessionPath(gSessionPath);
+		test(r==KErrNone);
+		test.Next(_L("Run all other tests from \\F32-TST\\TDIRS\\"));
+		gTestedZ=ETrue;
+		}
+
+	Test8();
+	
+	Test7(); 
+
+	Test1();
+	Test2();
+	Test3();
+	Test4();
+	Test5();
+	Test6();
+	Test9();
+
+	TestSortByName();
+	TestSortByExt();
+	TestDirNameHandling();
+
+	CleanupL();
+	}