// 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();

 	}