// Copyright (c) 1996-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:
//

#include <f32file.h>
#include <e32test.h>
#include <hal.h>
#include "t_server.h"
#include "t_chlffs.h"

GLDEF_D RTest test(_L("T_FMAN"));

LOCAL_D CFileMan* gFileMan=NULL;
LOCAL_D TBool gAsynch=EFalse;
LOCAL_D TRequestStatus gStat;
LOCAL_D TBool testingInvalidPathLengths;

class CFileManObserver : public CBase, public MFileManObserver
	{
public:
	CFileManObserver(CFileMan* aFileMan);
	TControl NotifyFileManEnded();
private:
	CFileMan* iFileMan;
	};

LOCAL_D CFileManObserver* gObserver;

CFileManObserver::CFileManObserver(CFileMan* aFileMan)
//
// Constructor
//
	{
	__DECLARE_NAME(_S("CFileManObserver"));
	iFileMan=aFileMan;
	}

MFileManObserver::TControl CFileManObserver::NotifyFileManEnded()
//
// Called back after each FMan tick
//
	{
	TInt lastError=iFileMan->GetLastError();
	if (lastError!=KErrNone && lastError!=KErrBadName)
		{
		TFileName fileName=iFileMan->CurrentEntry().iName;
		if (gAsynch==EFalse)
			test.Printf(_L("CurrentEntry is %S\n"),&fileName);
		test(lastError==KErrAlreadyExists);
		test(fileName.MatchF(_L("PIPE1.PLP"))!=KErrNotFound || fileName.MatchF(_L("FOUR"))!=KErrNotFound || fileName.MatchF(_L("File*.TXT"))!=KErrNotFound  || fileName.MatchF(_L("ah"))!=KErrNotFound || fileName.MatchF(_L("a"))!=KErrNotFound);
		}
	return(MFileManObserver::EContinue);
	}

LOCAL_C void WaitForSuccess()
//
// Wait for gStat to complete with KErrNone
//
	{
	User::WaitForRequest(gStat);
	test(gStat==KErrNone);
	}

LOCAL_C void WaitForResult(TInt aResult)
//
// Wait for gStat to complete with aResult
//
	{
	User::WaitForRequest(gStat);
	test(gStat==aResult);
	}

LOCAL_C void TestResult(TInt aReturnVal, TInt aExpectedAsynchReturnStatus=KErrNone, TInt aExpectedSynchReturn=KErrNone)
//
// Test the result, wait for an asynchronous call
//
	{
	if (!gAsynch)
		test(aReturnVal==aExpectedAsynchReturnStatus);
	else
		{
		test(aReturnVal==aExpectedSynchReturn);
		WaitForResult(aExpectedAsynchReturnStatus);
		}
	}

LOCAL_C void RmDir(const TDesC& aDirName)
//
// Remove a directory
//
	{
	gFileMan->Attribs(aDirName, 0, KEntryAttReadOnly, 0, CFileMan::ERecurse);
	TInt r=gFileMan->RmDir(aDirName);
	test(r==KErrNone || r==KErrNotFound || r==KErrPathNotFound);
	}

LOCAL_C void Compare(const TDesC& aDir1,const TDesC& aDir2)
//
// Test that the contents of two directories are identical
//
	{

	CDirScan* scanDir1=CDirScan::NewL(TheFs);
	scanDir1->SetScanDataL(aDir1,KEntryAttMaskSupported,ESortByName);
	CDirScan* scanDir2=CDirScan::NewL(TheFs);
	scanDir2->SetScanDataL(aDir2,KEntryAttMaskSupported,ESortByName);

	FOREVER
		{
		CDir* entryList1;
		CDir* entryList2;

		scanDir1->NextL(entryList1);
		scanDir2->NextL(entryList2);

		if (entryList1==NULL || entryList2==NULL)
			{
			test(entryList1==NULL && entryList2==NULL);
			break;
			}

		TFileName abbPath1=scanDir1->AbbreviatedPath();
		TFileName abbPath2=scanDir2->AbbreviatedPath();
		test(abbPath1==abbPath2);

		TInt count1=entryList1->Count();
		TInt count2=entryList2->Count();
		test(count1==count2);

		while(count1--)
			{
			TEntry entry1=(*entryList1)[count1];
			TEntry entry2=(*entryList2)[count1];
			test(entry1.iName==entry2.iName);
			test(entry1.iAtt==entry2.iAtt);
			}

		delete entryList1;
		delete entryList2;
		}

	delete scanDir1;
	delete scanDir2;
	}

LOCAL_C void SetupDirectories(TBool aCreateFiles, TFileName* aDestOtherDrive)
//
// Set up a directory structure and files to test copying/moving across drives
//
	{
	TInt err = KErrNone;

	TFileName sourceName		= _L("\\F32-TST\\TFMAN\\source\\");
	TFileName sourceNameSubDir	= _L("\\F32-TST\\TFMAN\\source\\subdir\\");
	TFileName sourceCompare		= _L("\\F32-TST\\TFMAN\\compare\\");	
	TFileName sourceCompareSubDir		= _L("\\F32-TST\\TFMAN\\compare\\subdir\\");	
	TFileName destSameDrive		= _L("\\F32-TST\\TFMAN\\dest\\");	// Target destination on the same drive

	if(aDestOtherDrive)
		{
#if !defined(__WINS__)
		*aDestOtherDrive = gSessionPath[0] == 'C' ? _L("D:\\F32-TST\\TFMAN\\dest\\") : _L("C:\\F32-TST\\TFMAN\\dest\\");
#else
		*aDestOtherDrive = gSessionPath[0] == 'C' ? _L("Y:\\F32-TST\\TFMAN\\dest\\") : _L("C:\\F32-TST\\TFMAN\\dest\\");
#endif
		err = TheFs.MkDirAll(*aDestOtherDrive);
		test(err == KErrNone || err == KErrAlreadyExists);
		}

	err = TheFs.MkDirAll(sourceName);
	test(err == KErrNone || err == KErrAlreadyExists);

	err = TheFs.MkDirAll(sourceCompare);
	test(err == KErrNone || err == KErrAlreadyExists);

	err = TheFs.MkDirAll(destSameDrive);
	test(err == KErrNone || err == KErrAlreadyExists);

	if(aCreateFiles)
		{
		err = TheFs.MkDirAll(sourceNameSubDir);
		test(err == KErrNone || err == KErrAlreadyExists);

		err = TheFs.MkDirAll(sourceCompareSubDir);
		test(err == KErrNone || err == KErrAlreadyExists);
		
		for(TInt i=0; i<5; i++)
			{
			// Create a test file to be copied
			TFileName name = sourceName;
			name.Append(_L("File"));
			name.AppendNum(i);
			name.Append(_L(".TXT"));

			RFile file;
			err = file.Create(TheFs,name,EFileRead|EFileWrite);
			test(err == KErrNone || err == KErrAlreadyExists);
			file.Close();

			// ...and another to compare against
			name = sourceCompare;
			name.Append(_L("File"));
			name.AppendNum(i);
			name.Append(_L(".TXT"));

			err = file.Create(TheFs,name,EFileRead|EFileWrite);
			test(err == KErrNone || err == KErrAlreadyExists);
			file.Close();
			}
		}
	}

TBool CheckIfShortPathsAreSupported()
	{
	TBool ret = EFalse;
	TBuf<1+8+3+1+4> buf;
	_LIT(KTestFile, "\\longname1\\file");
	RmDir(_L("\\longname1\\"));
	MakeFile(KTestFile);
	TInt err = TheFs.GetShortName(_L("\\longname1\\"), buf);	
	if(err == KErrNone)
		{
		buf.Insert(0, _L("\\"));
		buf.Append(_L("\\file"));
		err = TheFs.Delete(buf);
		test(err == KErrNone);
  		ret = ETrue;
		}
	RmDir(_L("\\longname1\\"));
	return ret;
	}
	
	LOCAL_C void TestDelete()
//
// Test files are deleted
//
	{
	
	test.Next(_L("Set up files and start deleting"));

	MakeDir(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\EXE2.BIN"));
	
	TInt r;
	// absolute path for code warrior two more than wins (\epoc32\winscw\c vs \epoc32\wins\c)
#if defined(__WINSCW__)
	_LIT(KLongName1,"\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffd");
#else
	_LIT(KLongName1,"\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa");
#endif

_LIT(KInvalidLongName,"\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdffdsa23asdffdsa24asdffdsa25asdffdsa");
_LIT(KInvalidLongPath, "\\F32-TST\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\0495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\PLATTEST\\FileStore\\TestData\\20495_Folder\\middle.gif");
	if (testingInvalidPathLengths)
//	Create a path of greater 256 characters by renaming a directory and check it can be
//	manipulated (tests fix to F32)		
		{
	//	One long directory name - makes paths invalid	
		MakeDir(_L("\\TEST\\LONG\\NAME\\ABCDE"));
		MakeDir(_L("\\TEST\\LONG\\NAME\\ABCDE\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\ABCDE\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\ABCDE\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
		TFileName name1(KLongName1);
		r=gFileMan->Rename(_L("\\TEST\\LONG"),name1,CFileMan::EOverWrite);
		test(r==KErrNone);
	//	Two long directory names - makes paths invalid
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
		
		// Testing invalid long file name (i.e. >256) 
		r=gFileMan->Rename(_L("\\TEST\\LONG"),KInvalidLongName,CFileMan::EOverWrite);
		test(r==KErrBadName);
		
		// Testing invalid long path (i.e. >256)
		r=gFileMan->Rename(_L("\\TEST\\LONG"),KInvalidLongPath,CFileMan::EOverWrite);
		test(r==KErrBadName);

		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
		test(r==KErrNone);
		}

	//testing invalid source path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->Delete(_L(":C\\F32-TST\\TFMAN\\DELDIR\\*.TXT"));
		}
	else
		{
		r=gFileMan->Delete(_L(":C\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);

	//testing invalid source path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\:DELDIR\\*.TXT"));
		}
	else
		{
		r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\:DELDIR\\*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);

	//testing invalid source path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\:*.TXT"));
		}
	else
		{
		r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\:*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);

	if (!gAsynch)
		{
		r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"));
		TestResult(r);
		if (testingInvalidPathLengths)
			{
			TFileName name1(KLongName1);
			name1+=_L("\\NAME\\ABCDE\\*.*");
			r=gFileMan->Delete(name1);	
			test(r==KErrNone);

			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"));	
			test(r==KErrNone);
			}
		}
	else
		{
		gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),0,gStat);
		WaitForSuccess();
		if (testingInvalidPathLengths)
			{
			TFileName name1(KLongName1);
			name1+=_L("\\NAME\\ABCDE\\*.*");
			r=gFileMan->Delete(name1,0,gStat);	
			WaitForSuccess();
			test(r==KErrNone);
		
			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"),0,gStat);	
			WaitForSuccess();
			test(r==KErrNone);
			}
		}

	test.Next(_L("Check files are deleted"));
	RmDir(_L("\\F32-TST\\TFMAN\\After\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\EXE2.BIN"));
	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\*"));
	
	if (testingInvalidPathLengths)
		{
		r=gFileMan->RmDir(_L("\\TEST\\"));
		test(r==KErrNone);
		}

	/**
	Test wild card matching in short file names
	Note this test is only run on FAT file systems as 'short file names' are only
		supported by FAT.
	DEF130113: TTG:<Wild card characters cannot be handled in the short file names> 
	*/ 
	TInt theDrive; 
	r=TheFs.CharToDrive(gDriveToTest,theDrive);
	test(r==KErrNone);
    TFSName f;
	r = TheFs.FileSystemName(f, theDrive);
	test(r == KErrNone || r == KErrNotFound);
    if (f.FindF(_L("Fat")) == 0 )
    	{
    	MakeFile(_L("abcdefghi.txt"));
    	TInt err = gFileMan->Delete(_L("ABCDEF~*"));
    	test(err == KErrNone);
    	MakeFile(_L("abcdefghi.txt"));
    	err = gFileMan->Delete(_L("ABCDEF~*.TXT"));
    	test(err == KErrNone);
    	MakeFile(_L("abcdefghi.txt"));
    	err = gFileMan->Delete(_L("ABCDEF~*.?XT"));
    	test(err == KErrNone);
    	MakeFile(_L("abcdefghi.txt"));
    	err = gFileMan->Delete(_L("ABCDEF~1.*"));
    	test(err == KErrNone);
    	}
	}

LOCAL_C void TestCopy()
//
// Test copy
//
	{

	test.Next(_L("Test copy"));
	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));

	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NewDir\\ABC.DEF"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\EXE2.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA4.TXT"));

	test.Next(_L("Test copy files to the same directory"));
	TInt r;
	
	if (testingInvalidPathLengths)
//	Create a path of greater 256 characters by renaming a directory and check it can be
//	manipulated (tests fix to F32)		
		{
		MakeDir(_L("\\START\\LONG\\"));
		MakeDir(_L("\\FINISH\\"));
		MakeFile(_L("\\START\\LONG\\ABCDEFGH01ABCDEFGH01ABCDEFGH01ABCDEFGH01.txt"));
		MakeFile(_L("\\START\\LONG\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
		MakeFile(_L("\\START\\LONG\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
		MakeFile(_L("\\START\\LONG\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.txt"));
		r=gFileMan->Rename(_L("\\START\\LONG"),_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
		test(r==KErrNone);
		MakeDir(_L("\\START\\ASDFFDSA\\"));
		}

	//testing invalid source path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L(":C:\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L(":C:\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);
		
	//testing invalid target path at the beginning:  
		
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L(":C:\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L(":C:\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);
  
	//testing invalid source path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\:DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\:DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);
	
	//testing invalid target path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);

	//testing invalid source path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\:file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\:file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);	
	
	//testing invalid target path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\:rumba?.txt"),0);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\:DELDIR\\:rumba?.txt"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);
		
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0,gStat);
	TestResult(r,KErrAlreadyExists);

	if (!gAsynch)
		r = gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\rumba.txt"),0);
	else
		r = gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\rumba.txt"),0,gStat);
	TestResult(r,KErrNone);

	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\file1.txt"),0);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\file1.txt"),0,gStat);
	TestResult(r,KErrAlreadyExists);

	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
		test(r==KErrNone);
		if (testingInvalidPathLengths)
			{
			test.Next(_L("Test invalid length paths"));
			r=gFileMan->Copy(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"));
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\START\\"));
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\FINISH\\"));
			test(r==KErrNone);
			}
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"),0,gStat);
		WaitForSuccess();
		test(r==KErrNone);
		if (testingInvalidPathLengths)
			{
			test.Next(_L("Test invalid length paths (Asynch)"));
			r=gFileMan->Copy(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"),0,gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\START\\"),gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\FINISH\\"),gStat);
			WaitForSuccess();
			test(r==KErrNone);
			}
		}
	
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\NewDir\\*.*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\NewDir\\*.*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"),0,gStat);
	TestResult(r);

	test.Next(_L("Check files have been copied"));
	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\ABC.DEF"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));

	TFileName fn = _L("Z:\\TEST\\T_FSRV.CPP");
	fn[0] = gExeFileName[0];
	if (!gAsynch)
		r=gFileMan->Copy(fn,_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	else
		r=gFileMan->Copy(fn,_L("\\F32-TST\\TFMAN\\COPYDIR\\"),0,gStat);
	TestResult(KErrNone);

	TEntry entry;
	r=TheFs.Entry(_L("\\F32-TST\\TFMAN\\COPYDIR\\T_FSRV.CPP"),entry);
	test(r==KErrNone);
	test(entry.iName.MatchF(_L("T_FSRV.CPP"))!=KErrNotFound);
#if defined (__WINS__)
	test(entry.iAtt==KEntryAttArchive);
#else
	if (!IsTestingLFFS())
		test(entry.iAtt==KEntryAttReadOnly);
	else
		test(entry.iAtt&KEntryAttReadOnly); // ???
#endif
	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\COPYDIR\\T_FSRV.CPP"),0,KEntryAttReadOnly);
	test(r==KErrNone);

	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA?.TXT"));
	test(r==KErrNone);
	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA?.TXT"));
	test(r==KErrNone);
	
	}
LOCAL_C void TestDEF121663_Setup(TFileName& aSrcPath)
	{
	RmDir(aSrcPath);
	MakeDir(aSrcPath);
	
	for(TInt index=0; index<10; index++)
		{
		TFileName fileName;
	    fileName.Copy(aSrcPath);
	    fileName.Append(_L("FILE_"));fileName.AppendNum(index);fileName.Append(_L(".TXT"));
		MakeFile(fileName, _L8("Some Data"));
		}
	}
	
LOCAL_C void TestDEF121663()
	{
	test.Next(_L("++TestDEF121663"));
	
	gFileMan->SetObserver(NULL);
	TInt err = 0;
	TFileName srcPath = _L("C:\\TestDEF121663\\");
		
	TestDEF121663_Setup(srcPath);
	if(!gAsynch)
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::EOverWrite);
		}
	else
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::EOverWrite, gStat);
		}
	TestResult(err,KErrInUse,KErrInUse);

	TestDEF121663_Setup(srcPath);
	if(!gAsynch)
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663\\"),_L("C:\\TestDEF121663\\TestDEF121663\\"),CFileMan::EOverWrite);
		}
	else
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663\\"),_L("C:\\TestDEF121663\\TestDEF121663\\"),CFileMan::EOverWrite, gStat);
		}
	TestResult(err,KErrPathNotFound);
	
	TestDEF121663_Setup(srcPath);
	if(!gAsynch)
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663\\"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::EOverWrite);
		}
	else
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663\\"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::EOverWrite, gStat);
		}
	TestResult(err,KErrPathNotFound);

	TestDEF121663_Setup(srcPath);
	if(!gAsynch)
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663\\"),CFileMan::ERecurse|CFileMan::EOverWrite);
		}
	else
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663\\"),CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
		}
	TestResult(err,KErrInUse,KErrInUse);

	TestDEF121663_Setup(srcPath);
	if(!gAsynch)
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::ERecurse);
		}
	else
		{
		err = gFileMan->Move(_L("C:\\TestDEF121663"),_L("C:\\TestDEF121663\\TestDEF121663"),CFileMan::ERecurse, gStat);
		}
	TestResult(err,KErrInUse,KErrInUse);
	
	gFileMan->SetObserver(gObserver);
	// remove previous dirs
	RmDir(_L("C:\\TestDEF121663\\"));
	test.Next(_L("--TestDEF121663"));
	}

LOCAL_C void TestDEF123575()
	{
	test.Next(_L("++TestDEF123575"));
	TFileName srcPath;
	TFileName destPath;
	TInt err;
	//setup the initial directory structure
	srcPath = _L("\\F32-TST\\DEF123575\\SRCDIR\\CommonDIR\\temp\\temp1.1\\");
	destPath = _L("\\F32-TST\\DEF123575\\DSTDIR\\CommonDIR\\temp\\temp1.1\\");
	MakeDir(srcPath);
	MakeDir(destPath);
	MakeFile(_L("\\F32-TST\\DEF123575\\SRCDIR\\CommonDIR\\temp\\temp1.1\\FILE1.TXT"));
	
	srcPath = _L("\\F32-TST\\DEF123575\\SRCDIR\\CommonDIR");
	destPath = _L("\\F32-TST\\DEF123575\\DSTDIR\\");
	if(!gAsynch)
		{
		err = gFileMan->Move(srcPath,destPath,CFileMan::EOverWrite);
		}
	else
		{
		err = gFileMan->Move(srcPath,destPath,CFileMan::EOverWrite, gStat);
		}
	TestResult(err,KErrNone,KErrNone);

	//test that source directory is empty after move
	MakeDir(_L("\\F32-TST\\DEF123575\\AFTER\\"));
	Compare(_L("\\F32-TST\\DEF123575\\SRCDIR\\*"),_L("\\F32-TST\\DEF123575\\AFTER\\*"));
	//test that the files have been moved to the destination directory
	MakeDir(_L("\\F32-TST\\DEF123575\\AFTER\\CommonDIR\\temp\\temp1.1\\"));
	MakeFile(_L("\\F32-TST\\DEF123575\\AFTER\\CommonDIR\\temp\\temp1.1\\FILE1.TXT"));
	Compare(_L("\\F32-TST\\DEF123575\\DSTDIR\\*"),_L("\\F32-TST\\DEF123575\\AFTER\\*"));
	
	//delete the entire directory structure
	RmDir(_L("\\F32-TST\\DEF123575\\*"));
	test.Next(_L("--TestDEF123575"));
	}

LOCAL_C void TestDEF125570()
	{
	test.Next(_L("++TestDEF125570"));
	gFileMan->SetObserver(NULL);
	TInt err = KErrNone; 
	TFileName srcPath = _L("C:\\TestDEF125570\\src\\");
	TFileName trgPath = _L("C:\\TestDEF125570\\trg\\");

	// remove previous dirs
	RmDir(srcPath);
	RmDir(trgPath);

	//create src
	MakeDir(_L("C:\\TestDEF125570\\src\\DIR1\\"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR1\\File1.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR1\\File1.txt"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR1\\File2.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR1\\File2.txt"));
	MakeDir(_L("C:\\TestDEF125570\\src\\DIR1\\DIR11\\"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR1\\DIR11\\File1.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR1\\DIR11\\File1.txt"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR1\\DIR11\\File2.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR1\\DIR11\\File2.txt"));
	MakeDir(_L("C:\\TestDEF125570\\src\\DIR2\\"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR2\\File1.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR2\\File1.txt"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR2\\File2.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR2\\File2.txt"));
	MakeDir(_L("C:\\TestDEF125570\\src\\DIR2\\DIR12\\"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR2\\DIR12\\File1.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR2\\DIR12\\File1.txt"));
	MakeFile(_L("C:\\TestDEF125570\\src\\DIR2\\DIR12\\File2.txt"),_L8("FILE PATH : C:\\TestDEF125570\\SRC\\DIR2\\DIR12\\File2.txt"));

	//trg has at least one of the src subfolders
	MakeDir(_L("C:\\TestDEF125570\\trg\\DIR2\\"));
	MakeFile(_L("C:\\TestDEF125570\\trg\\DIR2\\File1.txt"),_L8("FILE PATH : C:\\TestDEF125570\\TRG\\DIR2\\File1.txt"));
	MakeFile(_L("C:\\TestDEF125570\\trg\\DIR2\\File2.txt"),_L8("FILE PATH : C:\\TestDEF125570\\TRG\\DIR2\\File2.txt"));

	if(!gAsynch)
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse|CFileMan::EOverWrite);
	else
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
	TestResult(err);
	gFileMan->SetObserver(gObserver);
	// remove previous dirs
	RmDir(_L("C:\\TestDEF125570\\"));
	test.Next(_L("--TestDEF125570"));
	}

LOCAL_C void TestDEF130404()
	{
	test.Printf(_L("++TestDEF130404"));
	
	TInt r = 0;
	TFileName trgPath;
	trgPath.Format(_L("%c:\\TestDEF130404\\Trg\\"), (TUint8)gDriveToTest);
	TFileName srcPath;
	srcPath.Format(_L("C:\\TestDEF130404\\Src\\DIR1\\"), (TUint8)gDriveToTest);

	// clean up before testing
	RmDir(srcPath);
	RmDir(trgPath);
	
	MakeDir(srcPath);
	srcPath.Append(_L("NODIR\\*.*"));
	MakeDir(trgPath);
	
	if(!gAsynch)
		r = gFileMan->Move(srcPath, trgPath, 0);
	else
	 	r = gFileMan->Move(srcPath, trgPath, 0, gStat);
	TestResult(r,KErrPathNotFound);
	
	// clean up before leaving
	trgPath.Format(_L("%c:\\TestDEF130404\\"), (TUint8)gDriveToTest);
	RmDir(trgPath);
	RmDir(_L("C:\\TestDEF130404\\"));
	
	test.Printf(_L("--TestDEF130404"));
	}


/**
This is to test that moving files to overwrite folders with the same names 
returns proper error code. 
*/
void TestPDEF137716()
	{
	test.Next(_L("Test moving files to overwrite folders or folders to files"));

	TInt err = KErrNone;
	gFileMan->SetObserver(NULL);
	
#if defined(__WINS__)
	_LIT(KFileToDirTargetName,			"Y:\\PDEF137716\\FileToDir_Target\\ITEM");
	_LIT(KFileToDirTargetNameWild,		"Y:\\PDEF137716\\FileToDir_Target\\");

	_LIT(KFixedTargetTestFolder,		"Y:\\PDEF137716\\");
	_LIT(KFileToDirTargetCreatePath,	"Y:\\PDEF137716\\FileToDir_Target\\ITEM\\");
#else
	_LIT(KFileToDirTargetName,			"D:\\PDEF137716\\FileToDir_Target\\ITEM");
	_LIT(KFileToDirTargetNameWild,		"D:\\PDEF137716\\FileToDir_Target\\");

	_LIT(KFixedTargetTestFolder,		"D:\\PDEF137716\\");
	_LIT(KFileToDirTargetCreatePath,	"D:\\PDEF137716\\FileToDir_Target\\ITEM\\");
#endif

	_LIT(KFixedSrouceTestFolder,		"\\PDEF137716\\");
	_LIT(KFileToDirSourceName,			"\\PDEF137716\\FileToDir_Source\\ITEM");
	_LIT(KFileToDirSourceNameWild,		"\\PDEF137716\\FileToDir_Source\\");
	
	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeDir(KFileToDirTargetCreatePath);
	MakeFile(KFileToDirSourceName);
	err = gFileMan->Move(KFileToDirSourceName, KFileToDirTargetNameWild, 0);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeDir(KFileToDirTargetCreatePath);
	MakeFile(KFileToDirSourceName);
	err = gFileMan->Move(KFileToDirTargetName, KFileToDirSourceNameWild, CFileMan::EOverWrite);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeDir(KFileToDirTargetCreatePath);
	MakeFile(KFileToDirSourceName);
	err = gFileMan->Move(KFileToDirSourceNameWild, KFileToDirTargetNameWild, 0);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeDir(KFileToDirTargetCreatePath);
	MakeFile(KFileToDirSourceName);
	err = gFileMan->Move(KFileToDirSourceNameWild, KFileToDirTargetNameWild, CFileMan::EOverWrite);
	test(err == KErrAccessDenied);

#if defined(__WINS__)
	_LIT(KDirToFileTargetName,			"Y:\\PDEF137716\\DirToFile_Target\\ITEM");
	_LIT(KDirToFileTargetNameWild,		"Y:\\PDEF137716\\DirToFile_Target\\");
#else
	_LIT(KDirToFileTargetName,			"D:\\PDEF137716\\DirToFile_Target\\ITEM");
	_LIT(KDirToFileTargetNameWild,		"D:\\PDEF137716\\DirToFile_Target\\");
#endif
	
	_LIT(KDirToFileSourceName,			"\\PDEF137716\\DirToFile_Source\\ITEM");
	_LIT(KDirToFileSourceNameWild,		"\\PDEF137716\\DirToFile_Source\\");

	_LIT(KDirToFileSourceCreatePath,	"\\PDEF137716\\DirToFile_Source\\ITEM\\");

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceName, KDirToFileTargetName, 0);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceName, KDirToFileTargetName, CFileMan::EOverWrite);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceName, KDirToFileTargetNameWild, 0);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceName, KDirToFileTargetNameWild, CFileMan::EOverWrite);
	test(err == KErrAccessDenied);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceNameWild, KDirToFileTargetNameWild, 0);
	test(err == KErrNotFound);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	MakeFile(KDirToFileTargetName);
	MakeDir(KDirToFileSourceCreatePath);
	err = gFileMan->Move(KDirToFileSourceNameWild, KDirToFileTargetNameWild, CFileMan::EOverWrite);
	test(err == KErrNotFound);

	RmDir(KFixedTargetTestFolder);
	RmDir(KFixedSrouceTestFolder);
	}

LOCAL_C void TestMove()
//
// Test Move
//
	{

	test.Next(_L("Test move"));
	RmDir(_L("\\F32-TST\\TFMAN\\MOVEDIR\\*"));

	MakeDir(_L("\\F32-TST\\TFMAN\\MOVEDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\EXE2.BIN"));

	TInt r=KErrNone;

	if (testingInvalidPathLengths)
//	Create a path of greater 256 characters by renaming a directory and check it can be
//	manipulated (tests fix to F32)		
		{
		MakeDir(_L("\\START\\LONG\\"));
		MakeDir(_L("\\FINISH\\"));
		MakeFile(_L("\\START\\LONG\\ABCDEFGH01ABCDEFGH01ABCDEFGH01ABCDEFGH01.txt"));
		MakeFile(_L("\\START\\LONG\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
		MakeFile(_L("\\START\\LONG\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
		MakeFile(_L("\\START\\LONG\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.txt"));
		r=gFileMan->Rename(_L("\\START\\LONG"),_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
		test(r==KErrNone);

	//	Two long directory names - makes paths invalid
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
		test(r==KErrNone);
	
		MakeDir(_L("\\START\\ASDFFDSA\\"));
		}

	//testing invalid source path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->Move(_L(":C:\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L(":C:\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);
		
	//testing invalid target path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L(":C:\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L(":C:\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);

	//testing invalid source path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\:DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\:DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);
	
	//testing invalid target path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\:DELDIR\\FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\:DELDIR\\FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);

	//testing invalid source path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\:FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\:FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);
	
	//testing invalid target path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\:FILE1.TXT"));
		}
	else
		{
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\:FILE*.TXT"),0,gStat);
		}
	TestResult(r,KErrBadName,KErrNone);	
	

	if (!gAsynch)
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"));
	else
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE?.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE*.TXT"),0,gStat);
	TestResult(r,KErrNone);

	if ((!gAsynch)&&(testingInvalidPathLengths))
		{
		r=gFileMan->Move(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"));
		test(r==KErrNone);
		
		r=gFileMan->Move(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\*.*"),_L("\\FINISH\\"), CFileMan::EOverWrite | CFileMan::ERecurse);
		test(r==KErrNone);

		r=gFileMan->RmDir(_L("\\START\\"));
		test(r==KErrNone);
		r=gFileMan->RmDir(_L("\\FINISH\\"));
		test(r==KErrNone);
		}
	if ((gAsynch)&&(testingInvalidPathLengths))
		{
		r=gFileMan->Move(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"),CFileMan::EOverWrite,gStat);
		User::WaitForRequest(gStat);
		test(r==KErrNone);
		r=gFileMan->Move(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\*.*"),_L("\\FINISH\\"), CFileMan::EOverWrite | CFileMan::ERecurse,gStat);
		User::WaitForRequest(gStat);
		test(r==KErrNone);
		r=gFileMan->RmDir(_L("\\START\\"),gStat);
		WaitForSuccess();
		test(r==KErrNone);
		r=gFileMan->RmDir(_L("\\FINISH\\"),gStat);
		WaitForSuccess();
		test(r==KErrNone);
		}

	if (!gAsynch)
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	else
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),0,gStat);
	TestResult(r,KErrNone);

	if (!gAsynch)
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\MOVEDIR\\"));
	else
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\MOVEDIR\\"),0,gStat);
	TestResult(r);

	if (!gAsynch)
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR.\\FILE*.TXT"));
	else
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR\\FILE*.TXT"),0,gStat);
	TestResult(r,KErrNotFound);

	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	if (!gAsynch)
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR\\FILE1.TXT"),0);
	else
		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR\\FILE1.TXT"),0,gStat);
	TestResult(r,KErrAlreadyExists);
	r=TheFs.Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	test(r==KErrNone);

	test.Next(_L("Check files have been moved"));
	RmDir(_L("\\F32-TST\\TFMAN\\AFTER\\*"));
	MakeDir(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\EXE2.BIN"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\DELDIR\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\AFTER\\*"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE3.TXT"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\MOVEDIR\\*"));

	if (testingInvalidPathLengths)
		{
		r=gFileMan->RmDir(_L("\\TEST\\"));
		test(r==KErrNone);
		}
	// Test moving directory to its subdirectory
	TestDEF121663();
	TestDEF123575();
	//Test Move when trg has at least one of the src dirs
	TestDEF125570();
	//Test move when the src doesn't fully exist 
	TestDEF130404();
	
	// Test moving files to overwrite folders that have the same names.
	TestPDEF137716();
	}

LOCAL_C void TestSimultaneous()
//
// Create and run two CFileMen simultaneously
//
	{

	test.Next(_L("Create and run two CFileMans simultaneously"));
	RmDir(_L("\\F32-TST\\TFMAN\\fman2\\"));

	MakeDir(_L("\\F32-TST\\TFMAN\\FMAN1\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\FMAN2\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN1\\ROD.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN1\\JANE.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN1\\FREDDY.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN2\\BORIS.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN2\\FREDRICK.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN2\\PETER.TXT"));

	CFileMan* fman=CFileMan::NewL(TheFs);
	TRequestStatus stat1;
	TInt r=fman->Delete(_L("\\F32-TST\\TFMAN\\FMAN1\\*.*"),0,stat1);
	test(r==KErrNone);
	r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\FMAN2\\*.TXT"),_L("\\F32-TST\\TFMAN\\FMAN2\\*.EXT"),0,gStat);
	test(r==KErrNone);
	FOREVER
		{
		if (stat1!=KRequestPending && gStat!=KRequestPending)
			break;
		User::WaitForAnyRequest();
		}
	test(stat1==KErrNone && gStat==KErrNone);
	delete fman;
	
	test.Next(_L("Check all files"));
	RmDir(_L("\\F32-TST\\TFMAN\\AFTER\\*"));

	MakeDir(_L("\\F32-TST\\TFMAN\\AFTER\\"));
	Compare(_L("\\F32-TST\\TFMAN\\After\\*"),_L("\\F32-TST\\TFMAN\\FMAN1\\*"));

	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\BORIS.EXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FREDRICK.EXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\PETER.EXT"));
	Compare(_L("\\F32-TST\\TFMAN\\After\\*"),_L("\\F32-TST\\TFMAN\\FMAN2\\*"));
	}

LOCAL_C void TestDEF092084()
	{
	if(gAsynch)  
		{
		return;
		}
	MakeDir(_L("\\DEF092084"));
	MakeFile(_L("\\DEF092084\\FILE1.TXT"));
	
	TInt r = gFileMan->Rename(_L("\\DEF092084\\*.TXT"),_L("\\DEF092084\\*.DDB"), CFileMan::EOverWrite);
	test(r==KErrNone); 
	CheckFileExists(_L("\\DEF092084\\FILE1.DDB"), KErrNone);
	
	r = gFileMan->Rename(_L("\\DEF092084\\?*.DD?"),_L("\\DEF092084\\?*.TXT"), CFileMan::EOverWrite);
	test(r==KErrNone); 
	CheckFileExists(_L("\\DEF092084\\FILE1.TXT"), KErrNone);
	
	RmDir(_L("\\DEF092084\\"));  
	}
  
//--------------------------------------------- 
//! @SYMTestCaseID			PBASE-T_FMAN-0542
//! @SYMTestType			UT 
//! @SYMREQ					INC109754
//! @SYMTestCaseDesc		1. Tests that CFileMan::Rename() does not incorrectly remove empty source directory
//! @SYMTestActions			Renames the only file from source directory to target directory, then check if 
//!							the empty source directory still exists.
//!							2. Tests the trailing backslash ("\") is interpreted to ("\*.*").
//! @SYMTestExpectedResults	The operation completes with error code KErrNone;
//!							The empty source directory still exists.
//! @SYMTestPriority		High
//! @SYMTestStatus			Implemented 
//--------------------------------------------- 	
void TestINC109754()
	{
	test.Next(_L("Test empty source directory should exist after contents being renamed (INC109754)"));
	TInt r = KErrNone;
	// Setting up comparing dir
	RmDir(		_L("\\F32-TST\\TFMAN\\INC109754_C\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC109754_C\\SRC\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC109754_C\\TRG\\FILE.TXT"));

	// Setting up testing dir
	RmDir(		_L("\\F32-TST\\TFMAN\\INC109754\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\FILE.TXT"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"));

	// Test case 1: CFileMan::Rename(_L("C:\\SRC\\"), 	_L("C:\\TRG\\"));
	if (!gAsynch)
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\"),_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"));
	else
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\"),_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"),0,gStat);
	TestResult(r);
	Compare(_L("\\F32-TST\\TFMAN\\INC109754\\"), _L("\\F32-TST\\TFMAN\\INC109754_C\\"));
	
	// Setting up testing dir
	RmDir(		_L("\\F32-TST\\TFMAN\\INC109754\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\FILE.TXT"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"));

	// Test case 2: CFileMan::Rename(_L("C:\\SRC\\*.*"), 	_L("C:\\TRG\\"));
	if (!gAsynch)
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"));
	else
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\INC109754\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\INC109754\\TRG\\"),0,gStat);
	TestResult(r);
	Compare(_L("\\F32-TST\\TFMAN\\INC109754\\"), _L("\\F32-TST\\TFMAN\\INC109754_C\\"));
	}


/*
Test code for INC111038() and executed with Cache enabled and FS_NOT_RUGGED.
*/

LOCAL_C void TestINC111038()
	{
	////////////////////////////////////////////////////////
	////

	TInt r;

	test.Next(_L("Example of incorrect attribute flushing"));
	////
	////////////////////////////////////////////////////////
	////
	_LIT(KTestFile, "\\TESTFILE.TXT");
	
	
	////////////////////////////////////////////////////////
	//// 2: Create Test File
	////
	test.Printf(_L("2: Create Test File\n"));
	RFile testFile;
	r = testFile.Create(TheFs, KTestFile, EFileRead | EFileWrite);
	test(r == KErrNone);

	////////////////////////////////////////////////////////
	//// 3: Populate Data
	////
	test.Printf(_L("\n3: Populate testFile1 Data\n"));
	r = testFile.Write(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
	test(r == KErrNone);


	////////////////////////////////////////////////////////
	//// 4: Get Initial Attributes
	////
	test.Printf(_L("\n4: Get Initial Attributes\n"));
	TUint atts = 0;
	r = testFile.Att(atts);
	test(r == KErrNone);
	test.Printf(_L("\n   Attributes: %08x"), atts);

	////////////////////////////////////////////////////////
	//// 5: Set KEntryAttHidden Attribute
	////
	test.Printf(_L("\n5: Set KEntryAttHidden Attribute"));
	r = testFile.SetAtt(KEntryAttHidden, 0);
	test(r == KErrNone);

	
	////////////////////////////////////////////////////////
	//// 6: Verify KEntryAttHidden Attribute is set
	////
	test.Printf(_L("\n6: Verify KEntryAttHidden Attribute is set for testFile1"));
	r = testFile.Att(atts);
	test(r == KErrNone);
	test(atts & KEntryAttHidden);


  	////////////////////////////////////////////////////////
	//// 7: Read Data from beginning of file
	////
	test.Printf(_L("\n7: Read Data from beginning of file testFile1\n"));
	TBuf8<4> data;
	r = testFile.Read(0, data);
	test(r == KErrNone);


     ////////////////////////////////////////////////////////
	//// 8: Close file
	////
	test.Printf(_L("\n8: Close all the testFiles"));
	testFile.Close();
	

   	////////////////////////////////////////////////////////
	//// 9: Verify KEntryAttHidden is present
	////
	test.Printf(_L("\n9: Verify KEntryAttHidden is present"));
	r = TheFs.Att(KTestFile, atts);
	test(r == KErrNone);
	test.Printf(_L(" \n Finally, attributes are : %08x"), atts);
	test(atts & KEntryAttHidden);
	
	
	test.Printf(_L("10: Delete Test File"));
	 r = TheFs.Delete(KTestFile);
	test(r == KErrNone || r == KErrNotFound);

	}
	
LOCAL_C void TestDEF113299()
	{
	test.Next(_L("TestDEF113299"));
	
	TInt err =0;
	TFileName srcFileName = _L("C:\\F32-TST\\TFMAN\\DEF113299\\src\\corner.html");
	TFileName trgFileName = _L("C:\\F32-TST\\TFMAN\\DEF113299\\src\\mi?d**dle.html");
	TFileName trgInvalidFileName = _L("C:\\F32-TST\\TFMAN\\DEF113299\\src\\mi?d**dle>.html"); // Invalid filename
	TFileName renamedFileName = _L("C:\\F32-TST\\TFMAN\\DEF113299\\src\\mirderdle.html");
	
	RmDir(_L("C:\\F32-TST\\TFMAN\\DEF113299\\"));
	MakeFile(srcFileName,_L8("Test Data"));
	if (!gAsynch)
		err = gFileMan->Rename(srcFileName,trgInvalidFileName);
	else
		err = gFileMan->Rename(srcFileName,trgInvalidFileName, 0, gStat);
	TestResult(err,KErrBadName);
		
	if(!gAsynch)
		err = gFileMan->Rename(srcFileName,trgFileName);
	else
		err = gFileMan->Rename(srcFileName,trgFileName, 0, gStat);
	TestResult(err,KErrNone);
		
	CheckFileExists(renamedFileName,KErrNone,ETrue);
	}
	
LOCAL_C void TestRename()
//
// Test rename with wildcards
//
	{

	test.Next(_L("Rename with wildcards"));
	RmDir(_L("\\F32-TST\\TFMAN\\rename\\dest\\"));
	
	MakeDir(_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\DirTest\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\abcDEF.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\abxx.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\HELLO.SPG"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\SHEET1.SPR"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\DirTest.TXT\\Unchanged.txt"));

	TInt r;

	if (testingInvalidPathLengths)
//	Create a path of greater 256 characters by renaming a directory and check it can be
//	manipulated (tests fix to F32)		
		{
		MakeDir(_L("\\LONGNAME\\"));
		MakeDir(_L("\\LONGNAME\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\LONGNAME\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
		MakeFile(_L("\\LONGNAME\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
		MakeFile(_L("\\LONGNAME\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.bin"));
		r=gFileMan->Rename(_L("\\LONGNAME"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
		test(r==KErrNone);

	//	Two long directory names - makes paths invalid
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT.txt"));
		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE.txt"));
		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
		test(r==KErrNone);
		}

	//testing invalid source path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("::C\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("::C\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrBadName);
		
	//testing invalid target path at the beginning:  
		
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("::C\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("::C\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrBadName);
	
	//testing invalid source path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\:RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\:RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrNone);
	
	//testing invalid target path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\:RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\:RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrNone);

		//testing invalid source path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\:*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\:*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrNone);	
	
	//testing invalid target path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\:*.DDB"),CFileMan::EOverWrite);
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\:*.DDB"),CFileMan::EOverWrite,gStat);
		}
		TestResult(r,KErrBadName,KErrNone);
	
	if (!gAsynch)
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
		test(r==KErrNone);
		if (testingInvalidPathLengths)
			{
			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.txt"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.bin"));
			test(r==KErrBadName);
			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),_L("\\Shortened"),CFileMan::EOverWrite);
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\Shortened\\*.txt"),_L("\\Shortened\\*.cat"));
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\Shortened\\"));
			test(r==KErrNone);

			r=gFileMan->Rename(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\NotSoShortened"),CFileMan::EOverWrite);
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\TEST"),_L("\\OXO!"));
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\OXO!\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as"),_L("\\OXO!\\Shorter"));
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\OXO!\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.txt"),_L("\\TEST\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.cat"));
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\OXO!\\"));
			test(r==KErrNone);

			}
		}
	else
		{
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
		WaitForSuccess();
		if (testingInvalidPathLengths)
			{
			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.txt"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.bin"));
			test(r==KErrBadName);
			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),_L("\\Shortened"),CFileMan::EOverWrite,gStat);
			WaitForSuccess();
			r=gFileMan->Rename(_L("\\Shortened\\*.txt"),_L("\\Shortened\\*.bin"),0,gStat);
			WaitForSuccess();
			r=gFileMan->RmDir(_L("\\Shortened\\"),gStat);
			WaitForSuccess();

			r=gFileMan->Rename(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\NotSoShortened"),CFileMan::EOverWrite,gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\TEST"),_L("\\OXO!"),CFileMan::EOverWrite,gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\OXO!\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as"),_L("\\OXO!\\Shorter"),CFileMan::EOverWrite,gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->Rename(_L("\\OXO!\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.txt"),_L("\\TEST\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.cat"),CFileMan::EOverWrite,gStat);
			WaitForSuccess();
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\OXO!\\"));
			test(r==KErrNone);
			r=gFileMan->RmDir(_L("\\TEST\\"));
			test(r==KErrNone);
			}
		}
	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abcDEF.DDB"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abxx.DDB"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DirTest.DDB\\Unchanged.txt"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\AFTER\\DirTest\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\HELLO.SPG"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\SHEET1.SPR"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*"));

	if (!gAsynch)
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.TXT"));
	else
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.TXT"),0,gStat);
	TestResult(r);

	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abcDEF.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abxx.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DirTest.TXT\\Unchanged.txt"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*"));

	test.Next(_L("Test rename case of filenames"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CASETEST\\FileName1"));

	if (!gAsynch)
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\CASETEST\\FileName1"),_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"));
	else
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\CASETEST\\FileName1"),_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),0,gStat);
	TestResult(r);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CASETEST\\FileName1"),KErrNone,EFalse);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),KErrNone,ETrue);

	if (!gAsynch)
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),CFileMan::EOverWrite);
	else
		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),CFileMan::EOverWrite,gStat);
	TestResult(r);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CASETEST\\FILENAME1"),KErrNone,ETrue);

	// Test behaviour for omitted parameters
	// For this, default should be session path
	TFileName sessionPath;
	TInt err=TheFs.SessionPath(sessionPath);
	test(err==KErrNone);

	SetupDirectories(ETrue, NULL);
	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\dest\\"));
	test(err == KErrNone);

	err = gFileMan->Rename(_L("\\F32-TST\\TFMAN\\source"), _L(""));
	test(err == KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));
	SetupDirectories(ETrue, NULL);
	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));
	test(err == KErrNone);

	err = gFileMan->Rename(_L(""), _L("\\F32-TST\\TFMAN\\dest\\"));
	test(err == KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
		
	err=TheFs.SetSessionPath(sessionPath);
	test(err==KErrNone);
	
	TestINC109754();
	TestDEF092084();
	TestDEF113299();
	}

LOCAL_C void TestAttribs()
//
// Test attribs
//
	{

	test.Next(_L("Set file attributes"));
	MakeFile(_L("\\F32-TST\\TFMAN\\ATTRIBS\\Attrib1.AT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\ATTRIBS\\Attrib2.at"));

	TUint legalAttMask=KEntryAttMaskSupported&~(KEntryAttDir|KEntryAttVolume);
	TUint setMask=KEntryAttReadOnly;
	TUint clearMask=KEntryAttHidden|KEntryAttArchive;
	if (!gAsynch)
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),setMask,clearMask,TTime(0));
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),setMask,clearMask,TTime(0),0,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}
	
	CDirScan* scan=CDirScan::NewL(TheFs);
	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\ATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
	CDir* entryList;
	scan->NextL(entryList);
	TInt count=entryList->Count();
	test(count==2);
	TEntry entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("attrib1.AT"))!=KErrNotFound);
	test(entry.iAtt==KEntryAttReadOnly);
	entry=(*entryList)[1];
	test(entry.iName.MatchF(_L("attrib2.AT"))!=KErrNotFound);
	test(entry.iAtt==KEntryAttReadOnly);
	delete entryList;

	TDateTime dateTime(1990,ENovember,20,9,5,0,0);
	TTime time(dateTime); // FAT loses microseconds if try to convert HomeTime()

	if (!gAsynch)
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),0,legalAttMask,time);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),0,legalAttMask,time,0,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}
	
	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\ATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
	scan->NextL(entryList);
	count=entryList->Count();
	test(count==2);
	entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("attrib1.AT"))!=KErrNotFound);
	test(entry.iAtt==0);
	TDateTime dt=(entry.iModified).DateTime();
	test(dt.Year()==dateTime.Year());
	test(dt.Month()==dateTime.Month());
	test(dt.Day()==dateTime.Day());
	test(dt.Hour()==dateTime.Hour());
	test(dt.Minute()==dateTime.Minute());
	test(dt.Second()==dateTime.Second());
	test(entry.iModified==time);
	entry=(*entryList)[1];
	test(entry.iName.MatchF(_L("attrib2.AT"))!=KErrNotFound);
	test(entry.iAtt==0);
	test(entry.iModified==time);
	delete entryList;
	delete scan;
	TestINC111038();
	}
	
LOCAL_C void  TestINC091841()
	{
	if(gAsynch)  
		{
		return;
		}

	MakeDir(_L("\\12345678\\Book\\12345678\\"));
	TFileName longname;
	longname.Copy(_L("\\12345678\\Book\\12345678\\12345678901234567890123456789012345678901234567890.x"));
	MakeFile(longname);
	TFileName oldname = longname;
	TInt ret = KErrNone;
	while(ret == KErrNone)
		{
		oldname = longname;
		longname.Append(_L("xxxxx"));
		ret = TheFs.Replace(oldname, longname);
		}
	if(oldname.Length() >= KMaxFileName-5) // if not, it means that we won't be calling ShrinkNames !!
		{
		TInt r = gFileMan->Rename(_L("\\12345678\\Book\\12345678"),_L("\\INC091841\\Book\\012-235-abcd"),0);
		test(r==KErrNone);  
		CDir* dir;
		r = TheFs.GetDir(_L("\\INC091841\\Book\\012-235-abcd\\"), KEntryAttNormal, ESortNone, dir);
		test(r==KErrNone);   
		r = KErrNotFound;
		TInt dirlen = sizeof("\\INC091841\\Book\\012-235-abcd\\");
		for(TInt i=0; r==KErrNotFound && i<dir->Count(); i++)
			{
			if((*dir)[i].iName.Length() + dirlen > oldname.Length())
				{
				r = KErrNone;
				}
			}
		delete dir;
		test(r==KErrNone);  
		r = gFileMan->RmDir(_L("\\INC091841\\"));
		test(r==KErrNone);  
		}
	RmDir(_L("\\12345678\\"));
	}

LOCAL_C void TestRmDir()
//
// Test rmdir function
//
	{

	test.Next(_L("Test rmdir function"));

	MakeDir(_L("\\F32-TST\\TFMAN\\RMDIR\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RMDIR\\ALFRED.txt"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RMDIR\\RICHARD.txt"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RMDIR\\RMSUBDIR1\\RMSUBSUBDIR\\CHARLES.txt"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RMDIR\\RMSUBDIR2\\EDMUND.txt"));
	MakeDir(_L("\\F32-TST\\TFMAN\\TESTDIR\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\TESTDIR\\DEF123044.txt"));
	
	TInt r;
	
	if (testingInvalidPathLengths)
//	Create a path of greater 256 characters by renaming a directory and check it can be
//	manipulated (tests fix to F32)		
		{
		MakeDir(_L("\\LONGNAMETEST\\"));
		MakeDir(_L("\\LONGNAMETEST\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
		MakeFile(_L("\\LONGNAMETEST\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
		MakeFile(_L("\\LONGNAMETEST\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
		r=gFileMan->Rename(_L("\\LONGNAMETEST"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
		test(r==KErrNone);
		}

	//testing invalid source path at the beginning:
	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L(":C:\\F32-TST\\TFMAN\\RMDIR\\*.AT"));
		}
	else
		{
		r=gFileMan->RmDir(_L(":C:\\F32-TST\\TFMAN\\RMDIR\\*.AT"),gStat);
		}
	TestResult(r,KErrBadName,KErrBadName);
	
	//testing invalid source path at the middle:	
	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\:RMDIR\\*.AT"));
		}
	else
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\:RMDIR\\*.AT"),gStat);
		}
	TestResult(r,KErrBadName,KErrNone);

	//testing invalid source path at the end:	
	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\TESTDIR\\:DEF.txt"));
		}
	else
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\TESTDIR\\:DEF.txt"),gStat);
		}
	TestResult(r,KErrNone,KErrNone);
	
	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\RMDIR\\*.AT"));
		test(r==KErrNone);
			if (testingInvalidPathLengths)
			{
			r=gFileMan->RmDir(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\"));
			test(r==KErrNone);
			}
		}
	else
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\RMDIR\\*.AT"),gStat);
		test(r==KErrNone);
		WaitForSuccess();
		if (testingInvalidPathLengths)
			{
			r=gFileMan->RmDir(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\"),gStat);
			test(r==KErrNone);
			WaitForSuccess();
			}

		}

	TEntry entry;
	r=TheFs.Entry(_L("\\F32-TST\\TFMAN\\RMDIR"),entry);
	test(r==KErrNotFound);

	MakeDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\READONLY\\"),KEntryAttReadOnly,0);
	test(r==KErrNone);

	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
		test(r==KErrAccessDenied);
		}
	else
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"),gStat);
		test(r==KErrNone);
		WaitForResult(KErrAccessDenied);
		}

	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\READONLY\\"),0,KEntryAttReadOnly);
	test(r==KErrNone);

	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
	test(r==KErrNone);
	
	// Test behaviour for omitted parameters
	// For this, default should be session path
	TFileName sessionPath;
	r=TheFs.SessionPath(sessionPath);
	test(r==KErrNone);

	SetupDirectories(ETrue, NULL);
	r=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));

	// Default removal of session path
	r=gFileMan->RmDir(_L(""));
	test(r==KErrNone);

	r=TheFs.SetSessionPath(sessionPath);
	
	r = gFileMan->Rename(_L("\\F32-TST\\TFMAN\\source\\subdir"), _L("\\F32-TST\\TFMAN\\source\\tofail"), CFileMan::ERecurse);
	test(r == KErrPathNotFound);
	
	r = gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\"));
	test(r==KErrNone);
	MakeDir(_L("\\F32-TST\\TFMAN\\"));
	
	if(testingInvalidPathLengths)
		{
		TestINC091841();
		}

	//--------------------------------------------- 
	//! @SYMTestCaseID			PBASE-T_FMAN-0316
	//! @SYMTestType			UT 
	//! @SYMREQ					DEF099820
	//! @SYMTestCaseDesc		Test that CFileMan::RmDir() works when deleting a directory containing open files.
	//! @SYMTestActions			Open a file within a directory and try to remove the directory.
	//! @SYMTestExpectedResults	The operation completes with the error code KErrInUse.
	//! @SYMTestPriority		High
	//! @SYMTestStatus			Implemented 
	//--------------------------------------------- 	

	gFileMan->SetObserver(NULL);

	MakeDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\OPENFILE\\FILE.TXT"));

	RFile file;
	r = file.Open(TheFs,_L("\\F32-TST\\TFMAN\\OPENFILE\\FILE.TXT"), EFileRead | EFileShareExclusive);
	test(r==KErrNone);

	if (!gAsynch)
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
		test(r==KErrInUse);
		
		file.Close();
		
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
		test(r==KErrNone);
		}
	else
		{
		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"), gStat);
		test(r==KErrNone);
		WaitForResult(KErrInUse);

		file.Close();

		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"), gStat);
		test(r==KErrNone);
		WaitForResult(KErrNone);
		}

	gFileMan->SetObserver(gObserver);
	}

LOCAL_C void TestRecursiveCopy()
//
// Test the recursive copy function
//
	{

	test.Next(_L("Test recursive copy"));
	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));

	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\EXE2.BIN"));

	TInt r;
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\"),_L("\\F32-TST\\TFMAN\\COPYDIR"),CFileMan::ERecurse);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\"),_L("\\F32-TST\\TFMAN\\COPYDIR"),CFileMan::ERecurse,gStat);
	TestResult(r);

	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));
	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));

	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.BIN"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*.EXT"),CFileMan::ERecurse);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.BIN"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*.EXT"),CFileMan::ERecurse,gStat);
	TestResult(KErrNone);

	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\EXE1.EXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\EXE2.EXT"));
	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));

	// Test behaviour for omitted parameters
	// For this, default should be session path
	TFileName sessionPath;
	r=TheFs.SessionPath(sessionPath);
	test(r==KErrNone);

	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	r=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));

	// Default copy to session path
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\"),_L(""),CFileMan::ERecurse);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\"),_L(""),CFileMan::ERecurse,gStat);
	TestResult(KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	r=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\DELDIR\\"));

	// Default copy from session path
	if (!gAsynch)
		r=gFileMan->Copy(_L(""),_L("\\F32-TST\\TFMAN\\COPYDIR\\"),CFileMan::ERecurse);
	else
		r=gFileMan->Copy(_L(""),_L("\\F32-TST\\TFMAN\\COPYDIR\\"),CFileMan::ERecurse,gStat);
	TestResult(KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	RmDir(_L("\\F32-TST\\TFMAN\\DELDIR\\"));
	r=TheFs.SetSessionPath(sessionPath);
	test(r==KErrNone);
	}
	
LOCAL_C void TestRecursiveAttribs()
//
// Test set attribs recursively
//
	{

	test.Next(_L("Test recursive attribs"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\Attrib1.AT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\Attrib2.at"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\SUBDIR\\ATFILE.TXT"));

	if (!gAsynch)
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),KEntryAttReadOnly,0,TTime(0),CFileMan::ERecurse);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),KEntryAttReadOnly,0,TTime(0),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}

	CDir* entryList;
	CDirScan* scan=CDirScan::NewL(TheFs);
	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
	scan->NextL(entryList);
	TInt count=entryList->Count();
	test(count==3);
	TEntry entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("ATTRIB1.AT"))!=KErrNotFound);
	if (!IsTestingLFFS())
		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
	else
		test(entry.iAtt&KEntryAttReadOnly); // ???
	entry=(*entryList)[1];
	test(entry.iName.MatchF(_L("ATTRIB2.AT"))!=KErrNotFound);
	if (!IsTestingLFFS())
		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
	else
		test(entry.iAtt&KEntryAttReadOnly); // ???
	entry=(*entryList)[2];
	test(entry.iName.MatchF(_L("SUBDIR"))!=KErrNotFound);
	delete entryList;

	scan->NextL(entryList);
	count=entryList->Count();
	test(count==1);
	entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("ATFILE.TXT"))!=KErrNotFound);
	if (!IsTestingLFFS())
		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
	else
		test(entry.iAtt&KEntryAttReadOnly); // ???
	delete entryList;

	scan->NextL(entryList);
	test(entryList==NULL);

	if (!gAsynch)
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),0,KEntryAttReadOnly|KEntryAttArchive,TTime(0),CFileMan::ERecurse);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),0,KEntryAttReadOnly|KEntryAttArchive,TTime(0),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}

	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
	scan->NextL(entryList);
	count=entryList->Count();
	test(count==3);
	entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("ATTRIB1.AT"))!=KErrNotFound);
	test(entry.iAtt==KEntryAttNormal);
	entry=(*entryList)[1];
	test(entry.iName.MatchF(_L("ATTRIB2.AT"))!=KErrNotFound);
	test(entry.iAtt==KEntryAttNormal);
	entry=(*entryList)[2];
	test(entry.iName.MatchF(_L("SUBDIR"))!=KErrNotFound);
	delete entryList;

	scan->NextL(entryList);
	count=entryList->Count();
	test(count==1);
	entry=(*entryList)[0];
	test(entry.iName.MatchF(_L("ATFILE.TXT"))!=KErrNotFound);
	test(entry.iAtt==KEntryAttNormal);
	delete entryList;

	scan->NextL(entryList);
	test(entryList==NULL);
	delete scan;
	}

LOCAL_C void TestRecursiveDelete()
//
// Test Recursive delete
//
	{

	test.Next(_L("Test recursive delete"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECDELETE\\FULL\\GRAPE.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECDELETE\\FULL\\GRAPE.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECDELETE\\GRAPE.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECDELETE\\FILE1.TXT"));

	if (!gAsynch)
		{
		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\RECDELETE\\*.PLP"),CFileMan::ERecurse);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\RECDELETE\\*.PLP"),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}

	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FULL\\GRAPE.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE1.TXT"));
	Compare(_L("\\F32-TST\\TFMAN\\after\\*"),_L("\\F32-TST\\TFMAN\\RecDelete\\*"));
	}

LOCAL_C void TestINC108401()
  {
   	
   	test.Next(_L("Test INC108401 : starts"));
   	TInt err = 0;
   	
	TFileName trgPath = _L("?:\\F32-TST\\");

	if (gSessionPath[0]!='D'&& gSessionPath[0]!='Y')
		{
#if !defined(__WINS__)
		trgPath[0] = 'D';
#else
		trgPath[0] = 'Y';
#endif
		}
	else
		return;

	TFileName trgDir = trgPath;
	trgDir.Append(_L("TFMAN\\INC108401\\dest\\"));
	
	// Moving files and dirs ACROSS DRIVE.
  	err = 0;
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(trgDir);
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	// Synchronously
	if (!gAsynch)
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, 0);
	else // Asynchronously
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, 0, gStat);
	test.Next(_L("Test INC108401 : ACROSS DRIVES with 0"));
	TestResult(err);
	// cleanup the current drive
	RmDir(trgPath);
	// remove the F32-TST dir on the C: drive
	RmDir(_L("\\F32-TST\\TFMAN\\"));
	
	err = 0;
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(trgDir);
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	// Synchronously
	if (!gAsynch)
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, CFileMan::EOverWrite);
	else // Asynchronously
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, CFileMan::EOverWrite, gStat);
	test.Next(_L("Test INC108401 : ACROSS DRIVES with CFileMan::EOverWrite"));
	TestResult(err);
	// cleanup the current drive
	RmDir(trgPath);
	// remove the F32-TST dir on the C: drive
	RmDir(_L("\\F32-TST\\"));
	
	err = 0;
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(trgDir);
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	// Synchronously
	if (!gAsynch)
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, CFileMan::ERecurse);
	else // Asynchronously
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), trgDir, CFileMan::ERecurse, gStat);
	test.Next(_L("Test INC108401 : ACROSS DRIVES with CFileMan::ERecurse"));
	TestResult(err);
	// cleanup the current drive
	RmDir(trgPath);
	// remove the F32-TST dir on the C: drive
	RmDir(_L("\\F32-TST\\"));


	// Moving files and dirs on the SAME DRIVE.
	// case for gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), 0);
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\dest\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	// Synchronously
	if (!gAsynch)	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), 0);
	else // Asynchronously	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), 0, gStat);
	test.Next(_L("Test INC108401 : SAME DRIVE with 0"));
	TestResult(err);
	// test(err==KErrNone);
	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
	
	// case for gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite);
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\dest\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	// Synchronously
	if (!gAsynch)	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite);
	else // Asynchronously	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite, gStat);
	test.Next(_L("Test INC108401 : SAME DRIVE with CFileMan::EOverWrite"));
	TestResult(err);
	// test(err==KErrNone);
	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
	
	// case for gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite|CFileMan::ERecurse);
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\dest\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\file2"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\file1"));
	MakeFile(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\file1"),_L8("FILE PATH : \\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\file1"));
	// Synchronously
	if (!gAsynch)	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::ERecurse|CFileMan::EOverWrite);
	else // Asynchronously	
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
	test.Next(_L("Test INC108401 : SAME DRIVES with CFileMan::ERecurse|CFileMan::EOverWrite"));
	TestResult(err);
	// test(err==KErrNone);
	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
	
	// cleanup for the current drive
	RmDir(trgPath);
	RmDir(_L("\\F32-TST\\"));

	test.Next(_L("Test INC108401 : ends"));
  }

LOCAL_C void TestINC089638()
  {
	if(gAsynch)  
		{
		return;
		}
	RmDir(_L("\\INC089638\\source\\"));
	RmDir(_L("\\INC089638\\dest\\"));
	MakeFile(_L("\\INC089638\\source\\file1"));
	MakeFile(_L("\\INC089638\\source\\file2"));
	MakeFile(_L("\\INC089638\\source\\subdir1\\file3"));
	MakeFile(_L("\\INC089638\\source\\subdir1\\file4"));
	MakeFile(_L("\\INC089638\\source\\subdir2\\file5"));
	MakeFile(_L("\\INC089638\\source\\subdir2\\file6"));
	MakeDir(_L("\\INC089638\\dest\\"));
	test(TheFs.SetAtt(_L("\\INC089638\\source\\subdir1"), KEntryAttHidden, 0) == KErrNone);
	test(TheFs.SetAtt(_L("\\INC089638\\source\\subdir2"), KEntryAttReadOnly, 0) == KErrNone);
	
	TInt r = gFileMan->Move(_L("\\INC089638\\source\\"), _L("\\INC089638\\dest\\"), CFileMan::ERecurse);
	test(r==KErrNone);
	r = TheFs.RmDir(_L("\\INC089638\\source\\"));
	test(r==KErrNone);
	
	RmDir(_L("\\INC089638\\"));
  }

void TestINC101379()
	{
	TInt err;
	_LIT(KSourceDir,"\\INC101379\\dir\\");
	_LIT(KFile1, "\\INC101379\\dir\\file1.txt");
	_LIT(KFile2, "\\INC101379\\dir\\subdir\\file2.txt");
	_LIT(KFile3, "\\INC101379\\dir\\other\\file3.txt");
	MakeFile(KFile1, _L8("qwerty"));
	MakeFile(KFile2, _L8("abc"));
	MakeFile(KFile3, _L8("qwerty"));
	TFileName dest;
	dest.Copy(KSourceDir);
	dest.Append(_L("subdir"));
	gFileMan->SetObserver(NULL);
	if (!gAsynch)
		err = gFileMan->Move(KSourceDir, dest, CFileMan::ERecurse|CFileMan::EOverWrite);
	else
		err = gFileMan->Move(KSourceDir, dest, CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
	test(err==KErrInUse); // Recursive move prohibited
	if (gAsynch)
		WaitForResult(KErrInUse);
	CheckFileContents(KFile1, _L8("qwerty"));
	CheckFileContents(KFile2, _L8("abc"));
	CheckFileContents(KFile3, _L8("qwerty"));

	if (!gAsynch)
		err = gFileMan->Move(KSourceDir, dest, CFileMan::EOverWrite);
	else
		err = gFileMan->Move(KSourceDir, dest, CFileMan::EOverWrite, gStat);
	TestResult(err, KErrNone); // Non-recursive move must be OK

	_LIT(KFile1Moved, "\\INC101379\\dir\\subdir\\file1.txt");
	CheckFileContents(KFile1Moved, _L8("qwerty"));
	CheckFileContents(KFile2, _L8("abc"));
	CheckFileContents(KFile3, _L8("qwerty"));
	gFileMan->SetObserver(gObserver);
	RmDir(KSourceDir);
	RmDir(_L("\\INC101379\\"));
	}
	
 void TestINC099600() // and INC101061
	{
	_LIT(KDest,"C:\\DEST099600\\");
	TBuf<64> source;
	source.Format(_L("%c:\\INC099600\\"), (TUint) gDriveToTest);
	TBuf<64> src;
	TInt r;
	TBuf<64> dst;
	RmDir(source);
	RmDir(KDest);
	
	src = source;
	src.Append('a');
	MakeFile(src);
	TheFs.SetAtt(src, KEntryAttArchive, 0);
	src.Append('h');
	MakeFile(src);
	TheFs.SetAtt(src, KEntryAttArchive | KEntryAttHidden, 0);
	src.Append('s');
	MakeFile(src);
	TheFs.SetAtt(src, KEntryAttArchive | KEntryAttHidden | KEntryAttSystem, 0);
	src.Append('x');
	src.Append(KPathDelimiter);
	src.Append('a');
	MakeFile(src);
	TheFs.SetAtt(src, KEntryAttArchive, 0);
	src.Append('h');
	MakeFile(src);
	TheFs.SetAtt(src, KEntryAttArchive | KEntryAttHidden, 0);

	dst.Copy(KDest);
	dst.Append(_L("ahsx\\"));
	MakeDir(dst);

	TEntry entry;
	r = gFileMan->Move(src, KDest, 0); // ahsx\ah
	test(r == KErrNone);
	r = TheFs.Entry(src, entry);
	test(r == KErrNotFound);

	src.SetLength(src.Length()-1); // ahsx\a
	r = gFileMan->Move(src, KDest, 0);
	test(r == KErrNone);
	r = TheFs.Entry(src, entry);
	test(r == KErrNotFound);
	
	src.SetLength(src.Length()-3); // ahs
	r = gFileMan->Move(src, KDest, 0);
	test(r == KErrNone);
	r = TheFs.Entry(src, entry);
	test(r == KErrNotFound);
	
	src.SetLength(src.Length()-1); // ah
	r = gFileMan->Move(src, KDest, 0);
	test(r == KErrAlreadyExists);
	r = TheFs.Entry(src, entry);
	test(r == KErrNone);

	r = gFileMan->Move(src, KDest, CFileMan::EOverWrite); // ah
	test(r == KErrNone);
	r = TheFs.Entry(src, entry);
	test(r == KErrNotFound);

	src.SetLength(src.Length()-1); // a
	r = gFileMan->Move(src, KDest, 0);
	test(r == KErrAlreadyExists);
	r = TheFs.Entry(src, entry);
	test(r == KErrNone);

	r = gFileMan->Move(src, KDest, CFileMan::EOverWrite); // a
	test(r == KErrNone);
	r = TheFs.Entry(src, entry);
	test(r == KErrNotFound);

	RmDir(source);
	RmDir(KDest);
	}

void SetupDirectoriesForCase0520()
// Setup initial directory structure for test case PBASE-T_FMAN-0520
	{
	RmDir(		_L("\\F32-TST\\TFMAN\\INC106735\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB\\F_SUB.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB01\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB01\\SUB02\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	}

void SetupDirectoriesForCase0520Compare1()
// Comparing directory structure for recursive Move() without wildcard
	{
	RmDir(		_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_SUB.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	}

void SetupDirectoriesForCase0520Compare2()
// Comparing directory structure for recursive Move() with wildcard
	{
	RmDir(		_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_SUB.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\"));
	}

void SetupDirectoriesForCase0520Compare3()
// Comparing directory structure for recursive Copy() without wildcard
	{
	RmDir(		_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_SUB.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	}

void SetupDirectoriesForCase0520Compare4()
// Comparing directory structure for recursive Copy() with wildcard
	{
	RmDir(		_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_ROOT.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\F_SUB.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\F_SUB01.TXT"), _L8("blahblahblah"));
	MakeDir(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\"));
	MakeFile(	_L("\\F32-TST\\TFMAN\\INC106735_COM\\SUB01\\SUB02\\F_SUB02.TXT"), _L8("blahblahblah"));
	}

LOCAL_C void TestRecursiveMove()
//
// Test recursive move
//
	{
	test.Next(_L("Test recursive move"));
	RmDir(_L("\\F32-TST\\TFMAN\\RecMove2\\"));

	MakeFile(_L("\\F32-TST\\TFMAN\\RECMOVE\\FULL\\FILE2.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECMOVE\\FULL\\FILE3.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECMOVE\\FULL\\GRAPE.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECMOVE\\GRAPE.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\RECMOVE\\FILE1.PLP"));

	TInt err;
	if (!gAsynch)
		err=gFileMan->Move(_L("\\F32-TST\\TFMAN\\RECMOVE\\*.PLP"),_L("\\F32-TST\\TFMAN\\RECMOVE2\\"),CFileMan::ERecurse);
	else
		err=gFileMan->Move(_L("\\F32-TST\\TFMAN\\RECMOVE\\*.PLP"),_L("\\F32-TST\\TFMAN\\RECMOVE2\\"),CFileMan::ERecurse,gStat);
	TestResult(err);

	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FULL\\FILE2.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FULL\\FILE3.PLP"));
	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FILE1.PLP"));
	Compare(_L("\\F32-TST\\TFMAN\\after\\*"),_L("\\F32-TST\\TFMAN\\RecMOve2\\*"));

	//
	// Test moving empty directories (DEF073924)
	//
	test.Next(_L("Test moving empty directories"));

	SetupDirectories(EFalse, NULL);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNotFound);	// Expected - directory is empty

	// Test that all directories are still present
	TEntry entry;
	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
	test(err == KErrNone);
	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\dest\\"), entry);
	test(err == KErrNone);

	SetupDirectories(EFalse, NULL);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNone);		// Expected - should move (or rename) directory

	// Test directory has been moved
	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\dest\\source\\"), entry);
	test(err == KErrNone);
	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
	test(err == KErrNotFound);

	RmDir(_L("\\F32-TST\\TFMAN\\dest\\source\\"));

	//
	// Test moving when the source directory contains subdirectories (INC074828, INC078800)
	//
	test.Next(_L("Test moving a directory containing subdirectories"));

	SetupDirectories(ETrue, NULL);
	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse | CFileMan::EOverWrite);
	test(err == KErrNone);

	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));

	//--------------------------------------------- 
	//! @SYMTestCaseID			PBASE-T_FMAN-0160
	//! @SYMTestType			UT 
	//! @SYMREQ					DEF087791
	//! @SYMTestCaseDesc		Test that CFileMan::Move() works when the destination paths does not exist.
	//! @SYMTestActions			Copy directory structures to a non-existant directory on the same drive.
	//! @SYMTestExpectedResults	Completes with no error, files are copied and intermediate directories are created.
	//! @SYMTestPriority		High
	//! @SYMTestStatus			Implemented 
	//--------------------------------------------- 	
	test.Next(_L("Test moving when the target directory does not exist"));

	SetupDirectories(ETrue, NULL);
	
	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNone);

	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));

	SetupDirectories(ETrue, NULL);
	
	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest"), CFileMan::ERecurse);
	test(err == KErrNone);

	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));

	SetupDirectories(ETrue, NULL);
	
	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNone);

	MakeDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));
	RmDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));

	SetupDirectories(ETrue, NULL);

	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNone);

	CheckFileExists(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), KErrNotFound, ETrue);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\dest\\File1.TXT"),   KErrNone,     ETrue);

	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));

	// Test behaviour for omitted parameters
	// For this, default should be session path
	TFileName sessionPath;
	err=TheFs.SessionPath(sessionPath);
	test(err==KErrNone);

	SetupDirectories(ETrue, NULL);
	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\dest\\"));
	test(err == KErrNone);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L(""), CFileMan::ERecurse);
	test(err == KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));

	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));
	SetupDirectories(ETrue, NULL);
	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));
	test(err == KErrNone);

	err = gFileMan->Move(_L(""), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
	test(err == KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
		
	err=TheFs.SetSessionPath(sessionPath);
	test(err==KErrNone);

	//--------------------------------------------- 
	//! @SYMTestCaseID			PBASE-T_FMAN-0520
	//! @SYMTestType			UT 
	//! @SYMREQ					INC106735
	//! @SYMTestCaseDesc		Test that CFileMan::Move() (recursive mode) works properly when the destination
	//!							directory is sub-directory of the source directory. 
	//!							(e.g. "C:SRC\\*.TXT" -> "C:\\SRC\\SUB\\")
	//! @SYMTestActions			Move, copy files recursively from source directory to one of its sub-directory,
	//!							with or without wildcards applied.
	//! @SYMTestExpectedResults	Completes with no error, file(s) are moved or copied properly, and no redundant
	//!							movings or copyings are made for files in destination directory.
	//! @SYMTestPriority		High
	//! @SYMTestStatus			Implemented 
	//--------------------------------------------- 	
	test.Next(_L("Test recursive moving and copying to sub-directories"));
	// Testing recursive Move() without wildcard
	SetupDirectoriesForCase0520();
	SetupDirectoriesForCase0520Compare1();
	if (!gAsynch)
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC106735\\F_ROOT.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\*"), CFileMan::ERecurse);
	else
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC106735\\F_ROOT.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\*"), CFileMan::ERecurse, gStat);
	TestResult(err, KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\INC106735\\"), _L("\\F32-TST\\TFMAN\\INC106735_COM\\"));

	// Testing recursive Move() with wildcard
	SetupDirectoriesForCase0520();
	SetupDirectoriesForCase0520Compare2();
	if (!gAsynch)
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC106735\\*.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse);
	else
		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC106735\\*.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse, gStat);
	TestResult(err, KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\INC106735\\"), _L("\\F32-TST\\TFMAN\\INC106735_COM\\"));

	// Testing recursive Copy() without wildcard
	SetupDirectoriesForCase0520();
	SetupDirectoriesForCase0520Compare3();
	if (!gAsynch)
		err = gFileMan->Copy(_L("\\F32-TST\\TFMAN\\INC106735\\F_ROOT.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse);
	else
		err = gFileMan->Copy(_L("\\F32-TST\\TFMAN\\INC106735\\F_ROOT.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse, gStat);
	TestResult(err, KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\INC106735\\"), _L("\\F32-TST\\TFMAN\\INC106735_COM\\"));

	// Testing recursive Copy() with wildcard
	SetupDirectoriesForCase0520();
	SetupDirectoriesForCase0520Compare4();
	if (!gAsynch)
		err = gFileMan->Copy(_L("\\F32-TST\\TFMAN\\INC106735\\*.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse);
	else
		err = gFileMan->Copy(_L("\\F32-TST\\TFMAN\\INC106735\\*.TXT"), _L("\\F32-TST\\TFMAN\\INC106735\\SUB\\"), CFileMan::ERecurse, gStat);
	TestResult(err, KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\INC106735\\"), _L("\\F32-TST\\TFMAN\\INC106735_COM\\"));

	TestINC089638();
	TestINC101379();
	TestINC099600();  // and INC101061
	}


//
// A complex test directory structure...
//
LOCAL_D const TInt KNumFiles = 8;
LOCAL_D const TFileName complexFile[] = 
	{
	_L("\\F32-TST\\TFMAN\\complex\\dir1\\file1.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir1\\file2.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir1\\subdir1\\file3.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir1\\subdir1\\file4.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir12\\dir1\\file1.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir12\\dir1\\file2.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir12\\dir1\\subdir1\\file3.txt"),
	_L("\\F32-TST\\TFMAN\\complex\\dir12\\dir1\\subdir1\\file4.txt")
	};

//
// The expected result of moving the directory complex\\dir1 into complex\\dir2\\ *without* EOverWrite
//
LOCAL_D const TInt KNumFilesResult1 = 8;
LOCAL_D const TFileName complexResult1[] = 
	{
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir1\\file1.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir1\\file2.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir1\\subdir1\\file3.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir1\\subdir1\\file4.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir12\\dir1\\file1.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir12\\dir1\\file2.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir12\\dir1\\subdir1\\file3.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result1\\dir12\\dir1\\subdir1\\file4.txt")
	};

//
// The expected result of moving the directory complex\\dir1 into complex\\dir2\\ *with* EOverWrite
//
LOCAL_D const TInt KNumFilesResult2 = 4;
LOCAL_D const TFileName complexResult2[] = 
	{
	_L("\\F32-TST\\TFMAN\\complex_result2\\dir12\\dir1\\file1.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result2\\dir12\\dir1\\file2.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result2\\dir12\\dir1\\subdir1\\file3.txt"),
	_L("\\F32-TST\\TFMAN\\complex_result2\\dir12\\dir1\\subdir1\\file4.txt"),

	};


LOCAL_C void TestRecursiveMoveAcrossDrives()
//
// Test recursive move across drives
//
	{

	test.Next(_L("Test recursive move across drives"));

	TFileName trgDir   = _L("\\F32-TST\\TFMAN\\RECMOVE2\\");
	TFileName trgSpec  = _L("\\F32-TST\\TFMAN\\RECMOVE2\\*");


	if (gSessionPath[0]=='C')
		{
#if !defined(__WINS__)
		trgDir	   = _L("D:\\F32-TST\\TFMAN\\RECMOVE2\\");
		trgSpec	   = _L("D:\\F32-TST\\TFMAN\\RECMOVE2\\*");
#else
		trgDir     = _L("Y:\\F32-TST\\TFMAN\\RECMOVE2\\");
		trgSpec    = _L("Y:\\F32-TST\\TFMAN\\RECMOVE2\\*");
#endif
		}

	RmDir(trgDir);

	MakeFile(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\FULL\\FILE2.PLP"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\FULL\\FILE3.PLP"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\FULL\\GRAPE.TXT"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\GRAPE.TXT"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\FILE1.PLP"));

	TInt err;
	if (!gAsynch)
		err=gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\*.PLP"),trgDir,CFileMan::ERecurse);
	else
		err=gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\*.PLP"),trgDir,CFileMan::ERecurse,gStat);
	TestResult(err);

	RmDir(_L("C:\\F32-TST\\TFMAN\\after\\"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\AFTER\\FULL\\FILE2.PLP"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\AFTER\\FULL\\FILE3.PLP"));
	MakeFile(_L("C:\\F32-TST\\TFMAN\\AFTER\\FILE1.PLP"));
	Compare(_L("C:\\F32-TST\\TFMAN\\after\\*"),trgSpec);
	RmDir(_L("C:\\F32-TST\\TFMAN\\AFTER\\"));
	RmDir(_L("C:\\F32-TST\\TFMAN\\RECMOVE\\"));
	
	//
	// Test moving empty directories (DEF073924)
	//
	test.Next(_L("Test moving empty directories"));

	TFileName destOtherDrive;
	SetupDirectories(EFalse, &destOtherDrive);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse);
	test(err == KErrNotFound);	// Expected - directory is empty

	// Test that all directories are still present
	TEntry entry;
	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
	test(err == KErrNone);
	err = TheFs.Entry(destOtherDrive, entry);
	test(err == KErrNone);

	//--------------------------------------------- 
	//! @SYMTestCaseID			PBASE-T_FMAN-0571
	//! @SYMTestType			UT
	//! @SYMREQ					INC108401
	//! @SYMTestCaseDesc		This testcase tests the synchronous and asynchronous move operations exhaustively with flags set as 0, CFileMan::EOverWrite,
	//!							CFileMan::ERecurse on the SAME and ACROSS drives without trailing slash at the end of source dir path.
	//! @SYMTestActions			1. Copy directory structures to another directory across drive.
	//! 						2. Copy directory structures to another directory across drive overwriting duplicate files.
	//! 						3. Copy directory structures to another directory across drive.
	//! 						4. Copy directory structures to another directory on same drive.
	//! 						5. Copy directory structures to another directory on same drive overwriting duplicate files.
	//! 						6. Copy directory structures to another directory on same drive.
	//! @SYMTestExpectedResults 1. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory.
	//!							2. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory, duplicate files are updated.
	//!							3. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory.
	//!							4. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory.
	//!							5. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory, duplicate files are updated.
	//!							6. Completes with no error, the last directory and its contents are moved from the src directory to the destination directory.
	//! @SYMTestPriority		High
	//! @SYMTestStatus			Implemented
	//--------------------------------------------- 	

	TestINC108401();

	//
	// Test moving when the source directory contains subdirectories (INC074828, INC078800)
	//
	test.Next(_L("Test moving a directory containing subdirectories"));

	SetupDirectories(ETrue, &destOtherDrive);
	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse | CFileMan::EOverWrite);
	test(err == KErrNone);

	destOtherDrive.Append(_L("*"));
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);

	//--------------------------------------------- 
	//! @SYMTestCaseID			PBASE-T_FMAN-0161
	//! @SYMTestType			UT 
	//! @SYMREQ					DEF087791
	//! @SYMTestCaseDesc		Test that CFileMan::Move() works when the destination paths does not exist.
	//! @SYMTestActions			Copy directory structures to a non-existant directory on a different drive.
	//! @SYMTestExpectedResults Completes with no error, files are copied and intermediate directories are created.
	//! @SYMTestPriority		High
	//! @SYMTestStatus			Implemented 
	//--------------------------------------------- 	
	test.Next(_L("Test moving when the target directory does not exist"));

	SetupDirectories(ETrue, &destOtherDrive);
	
	RmDir(destOtherDrive);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse);
	test(err == KErrNone);

	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);

	SetupDirectories(ETrue, &destOtherDrive);
	
	RmDir(destOtherDrive);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), destOtherDrive, CFileMan::ERecurse);
	test(err == KErrNone);

	MakeDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
	destOtherDrive.Append(_L("source\\"));
	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);
	RmDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));

	SetupDirectories(ETrue, &destOtherDrive);

	RmDir(destOtherDrive);

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), destOtherDrive, CFileMan::ERecurse);
	test(err == KErrNone);

	CheckFileExists(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), KErrNotFound, ETrue);
	destOtherDrive.Append(_L("File1.TXT"));
	CheckFileExists(destOtherDrive, KErrNone, ETrue);

	RmDir(destOtherDrive);
	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));

	//
	// Test recursive move of complex directory structure into itself (INC078759)
	//

	test.Next(_L("Test recursive move of complex directory structure"));

	// Set up the test directory
	TInt level = 0;
	for(level=0; level < KNumFiles; level++)
		{
		err = TheFs.MkDirAll(complexFile[level]);
		test(err == KErrNone || err == KErrAlreadyExists);

		RFile file;
		err = file.Create(TheFs, complexFile[level], EFileRead | EFileWrite);
		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
		file.Close();
		}

	//
	// Move directory 'dir1' into 'dir12' *without* overwrite flag set
	//
	//  - This should fail, as 'dir12' already contains a directory called 'dir1'
	//  - No directories should be modified
	//

	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\complex\\dir1"), _L("\\F32-TST\\TFMAN\\complex\\dir12\\"), CFileMan::ERecurse);
	test(err == KErrAlreadyExists);

	for(level=0; level < KNumFilesResult1; level++)
		{
		err = TheFs.MkDirAll(complexResult1[level]);
		test(err == KErrNone || err == KErrAlreadyExists);

		RFile file;
		err = file.Create(TheFs, complexResult1[level], EFileRead | EFileWrite);
		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
		file.Close();
		}

	Compare(_L("\\F32-TST\\TFMAN\\complex_result1\\*"), _L("\\F32-TST\\TFMAN\\complex\\*"));

	//
	// Move directory 'dir1' into 'dir12' *with* overwrite flag set
	//
	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\complex\\dir1"), _L("\\F32-TST\\TFMAN\\complex\\dir12\\"), CFileMan::ERecurse | CFileMan::EOverWrite);
	test(err == KErrNone);

	for(level=0; level < KNumFilesResult2; level++)
		{
		err = TheFs.MkDirAll(complexResult2[level]);
		test(err == KErrNone || err == KErrAlreadyExists);

		RFile file;
		err = file.Create(TheFs, complexResult2[level], EFileRead | EFileWrite);
		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
		file.Close();
		}

	Compare(_L("\\F32-TST\\TFMAN\\complex_result2\\*"), _L("\\F32-TST\\TFMAN\\complex\\*"));
	
	// ...tidy up files
	for(level=0; level < KNumFiles; level++)
		TheFs.Delete(complexFile[level]);
	for(level=0; level < KNumFilesResult1; level++)
		TheFs.Delete(complexResult1[level]);
	for(level=0; level < KNumFilesResult2; level++)
		TheFs.Delete(complexResult2[level]);

	// ...tidy up directories
	for(level=0; level < KNumFiles; level++)
		TheFs.RmDir(complexFile[level]);
	for(level=0; level < KNumFilesResult1; level++)
		TheFs.RmDir(complexResult1[level]);
	for(level=0; level < KNumFilesResult2; level++)
		TheFs.RmDir(complexResult2[level]);

	TheFs.RmDir(_L("C:\\F32-TST\\TFMAN\\"));
	TheFs.RmDir(_L("C:\\F32-TST\\"));		
	}

class CFileManCopyAllCancel : public CBase, public MFileManObserver
	{
public:
	CFileManCopyAllCancel(CFileMan* aFileMan);
	TControl NotifyFileManStarted();
	TControl NotifyFileManEnded();
	
private:
	CFileMan* iFileMan;
	};


CFileManCopyAllCancel::CFileManCopyAllCancel(CFileMan* aFileMan)
//
// Constructor
//
	{

	__DECLARE_NAME(_S("CFileManCopyAllCancel"));
	iFileMan=aFileMan;
	}

MFileManObserver::TControl CFileManCopyAllCancel::NotifyFileManStarted()
//
// Observer for TestCopyAllCancel tests
//
	{
	
	return(MFileManObserver::ECancel);
	}

MFileManObserver::TControl CFileManCopyAllCancel::NotifyFileManEnded()
//
// Observer for TestCopyAllCancel tests
//
	{
	
	return(MFileManObserver::EContinue);
	}
	

	
LOCAL_C void TestCopyAllCancel()
//
// Test copy ( all cancel)
//
	{

	test.Next(_L("Test copy all cancel"));
	
	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));
	CFileManCopyAllCancel* fManObserver=new(ELeave) CFileManCopyAllCancel(gFileMan);
	CleanupStack::PushL(fManObserver);
	gFileMan->SetObserver(fManObserver);
	

	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EMPTY\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NewDir\\ABC.DEF"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\FILE4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\DELTEST\\EXE1.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\EXE2.BIN"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA4.TXT"));

	test.Next(_L("Test cancel copy all the files "));
	TInt r;
	
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\file?.txt"),_L("\\F32-TST\\TFMAN\\DELDIR\\rumba?.txt"),0,gStat);
	TestResult(r,KErrCancel);
	
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.txt"),_L("\\F32-TST\\TFMAN\\file1.txt"),0);
	else
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.txt"),_L("\\F32-TST\\TFMAN\\file1.txt"),0,gStat);
	TestResult(r,KErrCancel);
	gFileMan->SetObserver(gObserver);
	CleanupStack::PopAndDestroy();
	
	}

class CFileManObserverOverWrite : public CBase, public MFileManObserver
	{
public:
	CFileManObserverOverWrite(CFileMan* aFileMan);
	TControl NotifyFileManEnded();
private:
	CFileMan* iFileMan;
	};


CFileManObserverOverWrite::CFileManObserverOverWrite(CFileMan* aFileMan)
//
// Constructor
//
	{

	__DECLARE_NAME(_S("CFileManObserverOverWrite"));
	iFileMan=aFileMan;
	}


MFileManObserver::TControl CFileManObserverOverWrite::NotifyFileManEnded()
//
// Observer for testoverwrite tests
//
	{

	TInt lastError=iFileMan->GetLastError();
	if (lastError!=KErrNone)
		{
		test(lastError==KErrAlreadyExists);
		if (gAsynch==EFalse)
			{
			TFileName fileName=iFileMan->CurrentEntry().iName;
			test.Printf(_L("     %S already exists\n"),&fileName);
			}
		}
	return(MFileManObserver::EContinue);
	}

LOCAL_C void TestOverWrite()
//
// Test overwrite for copy and rename
//
	{

	test.Next(_L("Test overwrite option"));
	RmDir(_L("\\F32-TST\\TFMAN\\OVERWRITE\\"));
	CFileManObserverOverWrite* fManObserver=new(ELeave) CFileManObserverOverWrite(gFileMan);
	CleanupStack::PushL(fManObserver);
	gFileMan->SetObserver(fManObserver);

	TBuf8<128> contentsFile1=_L8("Test file one contents");
	TBuf8<128> contentsFile2=_L8("Test file two contents");

	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\FILE1.TXT"),contentsFile1);
	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\FILE2.TXT"),contentsFile2);

	if (!gAsynch)
		{
		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),0);
		test(r==KErrAlreadyExists);
		}
	else
		{
		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrAlreadyExists);
		}

	RFile f;
	TInt r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"),EFileRead);
	test(r==KErrNone);
	TBuf8<128> data;
	r=f.Read(data);
	test(r==KErrNone);
	test(data.Length()==0);
	f.Close();

	if (!gAsynch)
		{
		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),CFileMan::EOverWrite);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),CFileMan::EOverWrite,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}

	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"),EFileRead);
	test(r==KErrNone);
	r=f.Read(data);
	test(r==KErrNone);
	test(data==contentsFile1);
	f.Close();

	RmDir(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"));

	if (!gAsynch)
		{
	TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),0);
		test(r==KErrAlreadyExists);
		}
	else
		{
		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrAlreadyExists);
		}

	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"),EFileRead);
	test(r==KErrNone);
	r=f.Read(data);
	test(r==KErrNone);
	test(data.Length()==0);
	f.Close();

	if (!gAsynch)
		{
		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),CFileMan::EOverWrite);
		test(r==KErrNone);
		}
	else
		{
		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),CFileMan::EOverWrite,gStat);
		test(r==KErrNone);
		WaitForSuccess();
		}

	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"),EFileRead);
	test(r==KErrNone);
	r=f.Read(data);
	test(r==KErrNone);
	test(data==contentsFile2);
	f.Close();
	gFileMan->SetObserver(gObserver);
	CleanupStack::PopAndDestroy();
	}

LOCAL_C void TestErrorHandling()
//
// Test bad paths etc
//
	{

	test.Next(_L("Test error handling"));
	if (!gAsynch)
		{
		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\BADPATH\\*"));
		test(r==KErrPathNotFound);
		}
	else
		{
		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\BADPATH\\*"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrPathNotFound);
		}

	CFileMan* fMan=CFileMan::NewL(TheFs);
	TInt r;
	{
	for(TInt drvNum=EDriveA; drvNum<=EDriveZ; ++drvNum)
		{
		TDriveInfo drvInfo;
		if(KErrNone==TheFs.Drive(drvInfo, drvNum) && drvInfo.iType==EMediaNotPresent)
			{
			// found a non-extant drive, test it...
			_LIT(KBad,"?:\\BADPATH\\*");
			TBuf<16> bad(KBad);
			bad[0] = TUint16('A'+drvNum);
			TInt r=fMan->Delete(bad);
			test(r==KErrNotReady);
			break;
			}
		}
	}
	delete fMan;

	MakeFile(_L("\\ONE\\TWO\\FILE1.TXT"));
	MakeFile(_L("\\ONE\\TWO\\FOUR"));
	test.Next(_L("Test cyclic copy"));
	if (!gAsynch)
		r=gFileMan->Copy(_L("\\ONE\\TWO\\*"),_L("\\ONE\\TWO\\THREE\\"),CFileMan::ERecurse);
	else
		r=gFileMan->Copy(_L("\\ONE\\TWO\\*"),_L("\\ONE\\TWO\\THREE\\"),CFileMan::ERecurse,gStat);
	test(r==KErrArgument);

	test.Next(_L("Test src name == trg name"));
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR")); // default aSwitch=EOverWrite
		test(r==KErrNone);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR"), 0);
		test(r==KErrAlreadyExists);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR"),CFileMan::ERecurse);
		test(r==KErrAlreadyExists);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\F*R"),_L("\\ONE\\TWO\\FOUR"),CFileMan::ERecurse);
		test(r==KErrAlreadyExists);
		}
	else
		{
		r=gFileMan->Copy(_L("\\ONE\\TWO\\*.TXT"),_L("\\ONE\\TWO\\*.TXT"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrAlreadyExists);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\F*R"),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForResult(KErrNone);
		}
	RmDir(_L("\\ONE\\"));

	test.Next(_L("Test copy missing source and path"));
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"));
		test(r==KErrPathNotFound);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse);
		test(r==KErrPathNotFound);
		}
	else
		{
		r=gFileMan->Copy(_L("\\ONE\\TWO\\*.TXT"),_L("\\ONE\\TWO\\*.YYY"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrPathNotFound);
		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForResult(KErrPathNotFound);
		}
		
	test.Next(_L("Test copy missing source"));
	if (!gAsynch)
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\*.LPQ"),_L("\\ONE\\TWO\\*.YYY"));
		test(r==KErrNotFound);
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse);
		test(r==KErrNotFound);
		}
	else
		{
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),0,gStat);
		test(r==KErrNone);
		WaitForResult(KErrNotFound);
		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse,gStat);
		test(r==KErrNone);
		WaitForResult(KErrNotFound);
		}
		
	RmDir(_L("\\EMPTYSRC\\"));
 	MakeDir(_L("\\EMPTYSRC\\"));
 	RmDir(_L("\\EMPTYTRG\\"));
 	MakeDir(_L("\\EMPTYTRG\\"));
 	test.Next(_L("Test copy empty source directory"));
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"));
 		test(r==KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse);
 		test(r==KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"));
 		test(r==KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse);
 		test(r==KErrNotFound);
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), 0, gStat);
 		test(r==KErrNone);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse, gStat);
 		test(r==KErrNone);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), 0, gStat);
 		test(r==KErrNone);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse, gStat);
 		test(r==KErrNone);
 		WaitForResult(KErrNotFound);
 		}
 	RmDir(_L("\\EMPTYSRC\\"));
 	RmDir(_L("\\EMPTYTRG\\"));
	

	MakeFile(_L("Dummyfile"));
	test.Next(_L("Illegal names"));
	r=gFileMan->Attribs(_L(":C:"),0,0,TTime(0),0);
	test(r==KErrBadName);
	r=gFileMan->Copy(_L(":C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Copy(_L("Dummyfile"),_L(":C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Delete(_L(":C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Move(_L(":C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Move(_L("dummyFile"),_L(":C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Rename(_L(":C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Rename(_L("DummyFile"),_L(":C:"),0);
	test(r==KErrBadName);
	r=gFileMan->RmDir(_L("\\:C:\\"));
	test(r==KErrBadName);

	r=gFileMan->Attribs(_L("::C:"),0,0,TTime(0),0);
	test(r==KErrBadName);
	r=gFileMan->Copy(_L("::C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Copy(_L("Dummyfile"),_L("::C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Delete(_L("::C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Move(_L("::C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Move(_L("dummyFile"),_L("::C:"),0);
	test(r==KErrBadName);
	r=gFileMan->Rename(_L("::C:"),_L("newname"),0);
	test(r==KErrBadName);
	r=gFileMan->Rename(_L("DummyFile"),_L("::C:"),0);
	test(r==KErrBadName);
	r=gFileMan->RmDir(_L("::C:"));
	test(r==KErrBadName);
	r=TheFs.Delete(_L("DummyFile"));
	test(r==KErrNone);
	// test copying two files with identical names that do not exist
	_LIT(KNonExistent,"\\azzzz.txt");
	r=gFileMan->Copy(KNonExistent,KNonExistent,0);
	test(r==KErrNotFound);
	}

LOCAL_C void TestNameMangling()
//
// Synchronous test of name mangling
//
	{

	gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\"));
	MakeDir(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\abc.def"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\abcdefghijk.def"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\abc.defgh"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\abcdefghijk.defgh"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abc.def"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abcdefghijk.def"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abc.defgh"));
	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abcdefghijk.defgh"));

	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*.*"));
	test(r==KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\*"),_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*"));
	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*.*"));
	test(r==KErrNone);
	}

LOCAL_C void TestLongNames()
//
// Synchronous test of name mangling
//
	{
#if defined(__WINS__)
	if (gSessionPath[0]=='C')
		return;
#endif

	gFileMan->SetObserver(NULL);
	
	// Format the current drive
	Format(CurrentDrive());
	// Create Session Path
	CreateTestDirectory(_L("\\F32-TST\\TFMAN\\"));
	
	// Create 2 root directories with very long names
	TInt longFileLength = KMaxFileName-4;
	test.Next(_L("Test methods on long names"));
	TFileName longFileNameA;
	longFileNameA.SetLength(longFileLength);
	longFileNameA.Fill('A',longFileLength);
	TFileName longRootDirNameA=_L("\\");
	longRootDirNameA+=longFileNameA;
	longRootDirNameA+=_L("\\");
	TInt r=TheFs.MkDir(longRootDirNameA);
	test(r==KErrNone || r==KErrAlreadyExists);
	// Second folder
	TFileName longFileNameB;
	longFileNameB.SetLength(longFileLength);
	longFileNameB.Fill('B',longFileLength);
	TFileName longRootDirNameB=_L("\\");
	longRootDirNameB+=longFileNameB;
	longRootDirNameB+=_L("\\");
	r=TheFs.MkDir(longRootDirNameB);
	test(r==KErrNone || r==KErrAlreadyExists);
	
	TInt longFilePtrLength = KMaxFileName-3; // We do not want the trailing backslash
	TPtrC ptrLongFileA(longRootDirNameA.Ptr(),longFilePtrLength);
	TPtrC ptrLongFileB(longRootDirNameB.Ptr(),longFilePtrLength);
	
	// TInt CFileMan::Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
	// Tries to move a folder with a long name into another
	// This test will return KErrGeneral because the new path will exceed the maximum length
	// See KMaxFileName
	r=gFileMan->Move(ptrLongFileA,ptrLongFileB);
	test(r==KErrGeneral);
	
	r=gFileMan->RmDir(longRootDirNameA);
	test(r==KErrNone);
	r=gFileMan->Rename(ptrLongFileB,ptrLongFileA);
	test(r==KErrNone);
	r=gFileMan->RmDir(longRootDirNameB);
	test(r==KErrPathNotFound);
	r=gFileMan->RmDir(longRootDirNameA);
	test(r==KErrNone);


	TFileName longSubDirName=_L("\\Files\\");
	TPtrC longSubDirFileName(longFileNameA.Ptr(),longFilePtrLength-longSubDirName.Length());
	longSubDirName+=longSubDirFileName;
	longSubDirName+=_L("\\");
	r=TheFs.MkDirAll(longSubDirName);
	test(r==KErrNone);

	CDir* dirList;
	r=TheFs.GetDir(longSubDirName,KEntryAttMaskSupported,0,dirList);
	test(r==KErrNone);
	test(dirList->Count()==0);
	delete dirList;


	TPtrC ptrLongSubDirSrc(longSubDirName.Ptr(),longSubDirName.Length()-1);
	TPtrC ptrLongSubDirTrg(longRootDirNameA.Ptr(),longRootDirNameA.Length()-1);
	r=gFileMan->Copy(ptrLongSubDirSrc,ptrLongSubDirTrg);
	test(r==KErrNone);
	r=TheFs.MkDir(longRootDirNameB);
	test(r==KErrNone);
	r=gFileMan->Move(ptrLongSubDirSrc,longRootDirNameB);
	test(r==KErrBadName);
	r=TheFs.RmDir(longRootDirNameB);
	test(r==KErrNone);
	test(TheFs.RmDir(longSubDirName) == KErrNone);
	test(TheFs.RmDir(_L("\\Files\\")) == KErrNone);
	gFileMan->SetObserver(gObserver);
	}

LOCAL_C void TestFileAttributes()
//
// Test file attributes are copied and new settings
//
	{

	gFileMan->Delete(_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*.*"));
	MakeDir(_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\"));
	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\readonly.def"),KEntryAttReadOnly);
	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\readonlyhidden.def"),KEntryAttReadOnly|KEntryAttHidden);
	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\hiddensystem.def"),KEntryAttHidden|KEntryAttSystem);
	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\systemarchive.def"),KEntryAttArchive|KEntryAttSystem);

	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*.*"));
	test(r==KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*"));
	r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*"),0,KEntryAttReadOnly,TTime(0));
	test(r==KErrNone);
	r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*"),0,KEntryAttReadOnly,TTime(0));
	test(r==KErrNone);
	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\FILEATT\\"));
	test(r==KErrNone);
	}	

class CFileManObserverContinue : public CBase, public MFileManObserver
	{
public:
	CFileManObserverContinue(CFileMan* aFileMan);
	TControl NotifyFileManEnded();
private:
	CFileMan* iFileMan;
	};


CFileManObserverContinue::CFileManObserverContinue(CFileMan* aFileMan)
//
// Constructor
//
	{

	__DECLARE_NAME(_S("CFileManObserverOverWrite"));
	iFileMan=aFileMan;
	}


MFileManObserver::TControl CFileManObserverContinue::NotifyFileManEnded()
//
// Observer for testoverwrite tests
//
	{

	return(MFileManObserver::EContinue);
	}

LOCAL_C void TestCopyOpenFile()
//
// Copy a file while it is open
//
	{

	test.Next(_L("Copying open files"));

	CFileManObserverContinue* fManObserver=new(ELeave) CFileManObserverContinue(gFileMan);
	gFileMan->SetObserver(fManObserver);

	TBuf<256> contents;
	TPtrC8 bufPtr;
	CreateLongName(contents,gSeed,256);
	bufPtr.Set((TUint8*)contents.Ptr(),contents.Size());

	MakeFile(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),bufPtr);
	RFile f;
	TInt r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"));
	test(r==KErrNone);
	f.Close();
	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"),EFileRead);
	test(r==KErrNone);
	TBuf8<256*sizeof(TText)> temp;
	r=f.Read(temp);
	test(r==KErrNone);
	test(temp==bufPtr);
	r=f.Read(temp);
	test(r==KErrNone);
	test(temp.Length()==0);
	f.Close();

	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),EFileRead);
	test(r==KErrNone);
	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"));
	test(r==KErrInUse);
	f.Close();

	gFileMan->SetObserver(gObserver);
	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\FILECOPY\\"));
	test(r==KErrNone);
	delete fManObserver;
	}

void TestINC101844()
	{
	_LIT(KDest,"C:\\DEST101844\\");
	TBuf<64> source;
	source.Format(_L("%c:\\INC101844\\"), (TUint) gDriveToTest);
	TBuf<64> src;
	RmDir(source);
	RmDir(KDest);
	MakeDir(KDest);
	TInt r;
		
	src = source;
	src.Append(_L("file1"));
	MakeFile(src, _L8("blah"));
	TheFs.SetAtt(src, KEntryAttReadOnly, 0);
	src = source;
	src.Append(_L("file2"));
	MakeFile(src, _L8("blah"));
	TheFs.SetAtt(src, KEntryAttHidden, 0);
	src = source;
	src.Append(_L("file3"));
	MakeFile(src, _L8("blah"));
	TheFs.SetAtt(src, KEntryAttSystem, 0);
	src = source;
	src.Append(_L("subdir1\\file4"));
	MakeFile(src, _L8("blah"));
	TheFs.SetAtt(src, KEntryAttArchive, 0);
	src = source;
	src.Append(_L("subdir1"));
	TheFs.SetAtt(src, KEntryAttSystem | KEntryAttHidden, KEntryAttArchive);

	r = gFileMan->Move(source, KDest, 0);
	test(r==KErrNone);
	
	TEntry entry;
	src = KDest;
	src.Append(_L("file1"));
	r = TheFs.Entry(src, entry);
	test(r == KErrNone);
	test(entry.iAtt&KEntryAttReadOnly);

	src = KDest;
	src.Append(_L("file2"));
	r = TheFs.Entry(src, entry);
	test(r == KErrNone);
	test(entry.iAtt&KEntryAttHidden);

	src = KDest;
	src.Append(_L("file3"));
	r = TheFs.Entry(src, entry);
	test(r == KErrNone);
	test(entry.iAtt&KEntryAttSystem);

	src = source;
	src.Append(_L("subdir1\\"));
	r = gFileMan->Move(src, source, 0);
	test(r == KErrNone);

	r = TheFs.RmDir(src);
	test(r==KErrNone);
	src = source;
	src.Append(_L("file4"));
	r = TheFs.Delete(src);
	test(r==KErrNone);
	r = TheFs.RmDir(source);
	test(r==KErrNone);
	RmDir(KDest);	
	}

LOCAL_C void TestMoveAcrossDrives()
//
// Move a file from C: to the target drive
//
	{

	test.Next(_L("Move across drives"));

	TFileName trgDrive   = _L("\\");
	TFileName trgFile    = _L("\\Sketch");
	TFileName trgDir     = _L("\\DRIVEMOVE\\");
	TFileName trgDirFile = _L("\\DRIVEMOVE\\Sketch");

	if (gSessionPath[0]=='C')
		{
#if !defined(__WINS__)
		trgDrive   = _L("D:\\");
		trgFile    = _L("D:\\Sketch");
		trgDir     = _L("D:\\DRIVEMOVE\\");
		trgDirFile = _L("D:\\DRIVEMOVE\\Sketch");
#else
		trgDrive   = _L("Y:\\");
		trgFile    = _L("Y:\\Sketch");
		trgDir     = _L("Y:\\DRIVEMOVE\\");
		trgDirFile = _L("Y:\\DRIVEMOVE\\Sketch");
#endif
		}

	RmDir(trgDir);
	RmDir(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\"));

	MakeFile(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"));
		
	// Move Sketch from the source to target
	gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"),trgDrive);
	// Check Sketch no longer exists on source drive
	CheckFileExists(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"),KErrNotFound);
	// Check Sketch exists on target drive
	CheckFileExists(trgFile,KErrNone);

	MakeFile(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"));
	// Move Directory DRIVEMOVE from the source to target
	gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE"),trgDrive);
	// Check DRIVEMOVE no longer exists on source drive
	CheckFileExists(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"),KErrPathNotFound);
	// Check Sketch exists on target drive
	CheckFileExists(trgDirFile,KErrNone);

	RmDir(trgDir);
	test(TheFs.Delete(trgFile) == KErrNone);	

	TestINC101844();
	}

class CFileManObserverCopyAbort : public CBase, public MFileManObserver
	{
public:
	CFileManObserverCopyAbort(CFileMan* aFileMan);
	TControl NotifyFileManEnded();
	void SetAbortStep(TInt aAbortStep);
private:
	CFileMan* iFileMan;
	TInt iCurrentStep;
	};


CFileManObserverCopyAbort::CFileManObserverCopyAbort(CFileMan* aFileMan)
//
// Constructor
//
	: iFileMan(aFileMan),
	  iCurrentStep(0)
	{
	__DECLARE_NAME(_S("CFileManObserverCopyAbort"));
	}


void CFileManObserverCopyAbort::SetAbortStep(TInt aAbortStep)
//
// Set the step at which to cancel the operation
//
	{
	iCurrentStep = aAbortStep;
	}


MFileManObserver::TControl CFileManObserverCopyAbort::NotifyFileManEnded()
//
// Observer for testoverwrite tests
//
	{

	TInt lastError = iFileMan->GetLastError();
	test(lastError == KErrNone);

	TFileName srcfile;
	iFileMan->GetCurrentSource(srcfile);
	
	TInt action = iFileMan->CurrentAction();
	test(action == CFileMan::EMove   ||
		 action == CFileMan::EDelete ||
		 action == CFileMan::ERmDir);
		
	iCurrentStep--;
	return(iCurrentStep ? MFileManObserver::EContinue : MFileManObserver::EAbort);
	}

LOCAL_C void TestAbortedMoveAcrossDrives()
//
// Move a file from C: to Y:, and test various cancel conditions
//
	{

	test.Next(_L("Cancel Move across drives"));

	const TInt KNumFiles = 5;

	TFileName trgDirRoot = _L("\\F32-TST\\TFMAN\\");
	TFileName trgDirFull = _L("\\F32-TST\\TFMAN\\CANCELMOVE\\");
	TFileName trgDirFile = _L("\\F32-TST\\TFMAN\\CANCELMOVE\\FILE");

	if (gSessionPath[0]=='C')
		{
#if !defined(__WINS__)
		trgDirRoot = _L("D:\\F32-TST\\TFMAN\\");
		trgDirFull = _L("D:\\F32-TST\\TFMAN\\CANCELMOVE\\");
        trgDirFile = _L("D:\\F32-TST\\TFMAN\\CANCELMOVE\\FILE");
#else
		trgDirRoot = _L("Y:\\F32-TST\\TFMAN\\");
		trgDirFull = _L("Y:\\F32-TST\\TFMAN\\CANCELMOVE\\");
        trgDirFile = _L("Y:\\F32-TST\\TFMAN\\CANCELMOVE\\FILE");
#endif
		}

	gFileMan->RmDir(_L("C:\\F32-TST\\TFMAN\\CANCELMOVE\\"));

	CFileManObserverCopyAbort* fManObserver=new(ELeave) CFileManObserverCopyAbort(gFileMan);
	CleanupStack::PushL(fManObserver);

// Check that source files exist when interrupting the copy step
	TInt step = 0;
	TInt i = 0;
	for(step = 1; step <= KNumFiles+1; ++step)
		{
		for (i = 0; i < KNumFiles; i++)
			{
			TFileName sourceFile =_L("C:\\F32-TST\\TFMAN\\CANCELMOVE\\FILE");
			sourceFile.AppendNum(i);
            sourceFile.Append(_L(".TXT"));
			MakeFile(sourceFile);
			}

		gFileMan->RmDir(trgDirFull);

		fManObserver->SetAbortStep(step);
		gFileMan->SetObserver(fManObserver);
	
		TInt r;
		if (!gAsynch)
			r=gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\CANCELMOVE"),trgDirRoot, CFileMan::EOverWrite);
		else
			r=gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\CANCELMOVE"),trgDirRoot, CFileMan::EOverWrite, gStat);
		
		TestResult(r, (step <= KNumFiles) ? KErrCancel : KErrNone);

		gFileMan->SetObserver(NULL);
		
		// Check that the expected target files exist...
		CheckFileExists(trgDirFull, KErrNone, EFalse);
		for (i = 0; i < Min(step, KNumFiles); i++)
			{
			TFileName trgAfterFile = trgDirFile;
			trgAfterFile.AppendNum(i);
            trgAfterFile.Append(_L(".TXT"));
			CheckFileExists(trgAfterFile, KErrNone);
			}

		// Check that the expected source files still exist after the abort...
		CheckFileExists(_L("C:\\F32-TST\\TFMAN\\CANCELMOVE\\"), (step <= KNumFiles) ? KErrNone : KErrNotFound, EFalse);
		for (; i < KNumFiles; i++)
			{
			TFileName srcAfterFile =_L("C:\\F32-TST\\TFMAN\\CANCELMOVE\\FILE");
			srcAfterFile.AppendNum(i);
            srcAfterFile.Append(_L(".TXT"));
			CheckFileExists(srcAfterFile, KErrNone);
			}
		}
	
	gFileMan->SetObserver(NULL);
	CleanupStack::PopAndDestroy();
	
	RmDir(trgDirRoot); // "?:\\F32-TST\\TFMAN\\"
	TheFs.RmDir(trgDirRoot.Left(16));
	TheFs.RmDir(trgDirRoot.Left(10));
	TheFs.RmDir(_L("C:\\F32-TST\\TFMAN\\"));
	TheFs.RmDir(_L("C:\\F32-TST\\"));
	}


LOCAL_C void TestMoveEmptyDirectory()
//
//	"Try to move an empty directory C:\F32-TST\TFMAN\DRIVEMOVE\ to C:\"
//
	{

	test.Next(_L("Move empty directory"));

#if !defined(__WINS__)
	TFileName trgDrive=_L("D:\\");
#else
	if (gSessionPath[0]!='C')
		return;
	TFileName trgDrive=_L("C:\\");
#endif

	MakeDir(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\"));
	TInt r=gFileMan->Move(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\*"),trgDrive,CFileMan::ERecurse);
	test (r==KErrNotFound);
	}

LOCAL_C void TestCopyAndRename()
//
// Rename while copying files and directories
//
	{
	test.Next(_L("Rename while copying files and directories"));
	gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\CPMV"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\ONE_1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\ONE_2.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\ONE_3.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\TWOTWO.TWO"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE_4.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\ONE_5.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.GOD"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.BAD"));

	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\TWO.*"), _L("\\F32-TST\\TFMAN\\THREE.*"), CFileMan::ERecurse);
	test(r==KErrNone);

	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.TXT"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.GOD"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.BAD"), KErrNone);
	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.*"));
	test(r==KErrNone);

	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\TWO__1.TXT"));
	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\TWO__2.TXT"));

// copy and rename dir
	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE"), CFileMan::ERecurse);
	test(r==KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\*"));

// copy and move into another dir
	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO"), CFileMan::ERecurse);
	test(r==KErrNone);
	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO\\*"));

// copy and rename files and dirs in current dir
	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE*"), CFileMan::ERecurse);
	test(r==KErrNone);
//	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE2\\*"));

	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\THREEO.TWO"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO__1.TXT"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO__2.TXT"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.TXT"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.BAD"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.GOD"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\THREE1.TXT"), KErrNone);
	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\THREE2.TXT"), KErrNone);
	
	gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\CPMV\\"));
	}

void TestStackUsage(TInt aLevel, TThreadStackInfo& aStack)
	{
	// DEF104115
	_LIT(KDir, "\\DEF104115\\");
	_LIT(KFile1,   "\\DEF104115\\file1veryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryverylong.txt");
	_LIT(KFile2,   "\\DEF104115\\SUBDIR\\longfile2.txt");
	
	if(aLevel==0)
		{
		test.Next(_L("Test stack usage"));
		RmDir(KDir);
		MakeFile(KFile1, _L8("123456789012345678901234567890"));
		MakeFile(KFile2);
		}
	TInt r = KErrNone;
	char* start = NULL;
	char* end = NULL;
	TInt available = 0;
	TInt stacksize = aStack.iBase - aStack.iLimit;
	start = (char*)aStack.iLimit;
	end = (char*)&stacksize;
	available = (TInt)end - (TInt)start;
#ifdef __X86__
	if(available > 6 * 1024) // X86 uses about twice as much stack as ARM in debug mode, so double the number.
#else
	if(available > 3 * 1024) // don't touch this constant ... fix CFileMan instead!!
#endif
		{
		TestStackUsage(aLevel+1, aStack);
		return;
		}
		
	test.Printf(_L("Level:%d Available:%d\n"), aLevel, available);
	
	gFileMan->SetObserver(NULL);
	// Attribs
	r = gFileMan->Attribs(KDir, 0, 0, 0, CFileMan::ERecurse);
	test(r==KErrNone);

	// Move
	r = gFileMan->Move(KFile1, KFile2, CFileMan::ERecurse);
	test(r==KErrAlreadyExists);

	r = gFileMan->Move(KFile1, KFile2, CFileMan::ERecurse | CFileMan::EOverWrite);
	test(r==KErrNone);

	// Copy
	r = gFileMan->Copy(KFile2, KFile1, CFileMan::ERecurse);
	test(r==KErrNone);

	// Rename
	r = gFileMan->Rename(KFile1, KFile2, 0);
	test(r==KErrAlreadyExists);

	r = gFileMan->Rename(KFile1, KFile2, CFileMan::EOverWrite);
	test(r==KErrNone);

	// Delete
	r = gFileMan->Delete(KFile2, CFileMan::ERecurse);
	test(r==KErrNone);

	// RmDir
	r = gFileMan->RmDir(KDir);
	test(r==KErrNone);
	
	gFileMan->SetObserver(gObserver);
	}

LOCAL_C void InitialiseL()
//
// Set up test variables
//
	{

	gFileMan=CFileMan::NewL(TheFs);
	gObserver=new(ELeave) CFileManObserver(gFileMan);
	gFileMan->SetObserver(gObserver);
	}

LOCAL_C void Cleanup()
//
// Cleanup test variables
//
	{

	delete gFileMan;
	delete gObserver;
	}
	
LOCAL_C void SetupDirStructure(TFileName& aSrcPath,TFileName& aTrgPath)
	{
	TFileName tmpName = aSrcPath;
	
	// Create the TrgPath dirs
	MakeDir(aTrgPath);
	
	// Create the aSrcPath dirs
	tmpName = aSrcPath;
	tmpName.Append(_L("EmptyDir01\\"));
	MakeDir(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("EmptyDir02\\"));
	MakeDir(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("EmptyDir03\\"));
	MakeDir(tmpName);

	tmpName = aSrcPath;
	tmpName.Append(_L("FILE01.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("FILE02.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("FILE03.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir01\\EmptyDir01\\"));
	MakeDir(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir02\\EmptyDir02\\"));
	MakeDir(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir03\\EmptyDir03\\"));
	MakeDir(tmpName);

	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir01\\FILE01.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir01\\FILE02.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir01\\FILE03.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir02\\FILE01.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir02\\FILE02.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir02\\FILE03.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir03\\FILE01.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir03\\FILE02.TXT"));
	MakeFile(tmpName);
	
	tmpName = aSrcPath;
	tmpName.Append(_L("SubDir03\\FILE03.TXT"));
	MakeFile(tmpName);
	}
	
LOCAL_C void TestPDEF112148()
	{
	test.Next(_L("++TestPDEF112148 : \n"));
	
	TInt err = 0;
	
	TFileName trgPath;
	trgPath.Format(_L("%c:\\F32-TST\\TFMAN\\PDEF112148\\dest\\"), (TUint8)gDriveToTest);
	TFileName srcPath = _L("C:\\F32-TST\\TFMAN\\PDEF112148\\src\\");
		
	// Non-Recursive move
	// clean up before testing
	RmDir(srcPath);
	RmDir(trgPath);
	// Setup the directory structure
	SetupDirStructure(srcPath, trgPath);
	if(!gAsynch)
		err = gFileMan->Move(srcPath, trgPath, 0);
	else
	 	err = gFileMan->Move(srcPath, trgPath, 0, gStat);
	TestResult(err);

	// Verify src contents after move operation
	CDir *dir = NULL;
	err = TheFs.GetDir(srcPath, KEntryAttMaskSupported, ESortNone, dir);
	test(6 == dir->Count());
	delete dir;
	// Verify dest contents after move operation
	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
	test(3 == dir->Count());
	delete dir;
	
	// Recursive move with "\\" at the end of srcPath
	// clean up before execution	
	RmDir(srcPath);
	RmDir(trgPath);
	// Setup the directory structure
	SetupDirStructure(srcPath, trgPath);
	if(!gAsynch)
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse);
	else
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse, gStat);
	TestResult(err);
	
	// Verify src has no content
	err = TheFs.GetDir(srcPath, KEntryAttMaskSupported, ESortNone, dir);
	test(0 == dir->Count());
	delete dir;
	// Verify dest contents after move operation
	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
	test(9 == dir->Count());
	delete dir;
	
	// Recursive move without "\\" at the end of srcPath
	// clean up before execution
	RmDir(srcPath);
	RmDir(trgPath);
	// Setup the directory structure
	SetupDirStructure(srcPath, trgPath);
	// Remove the "\\" at the end of srcPath for Recursive Move
	srcPath.Delete(srcPath.Length()-1,1);
	if(!gAsynch)
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse);
	else
		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse, gStat);
	TestResult(err);
		
	// Add the "\\" at the end of srcPath for verification
	srcPath.Append(KPathDelimiter);
	// Verify src doesnt not exist
	err = gFileMan->RmDir(srcPath);
	test(err==KErrPathNotFound); // KErrPathNotFound expected as src has been moved to dest
	// Verify dest after move operation
	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
	test(1 == dir->Count());
	delete dir;
		
	// clean up before leaving
	RmDir(srcPath);
	RmDir(trgPath);

	test.Next(_L("--TestPDEF112148 : \n"));
	}
//---------------------------------------------
//! @SYMTestCaseID			PBASE-T_FMAN-2398
//! @SYMTestType			UT 
//! @SYMREQ					DEF130678
//! @SYMTestCaseDesc		Tests that CFileMan::Move itself does not leak any memory
//! @SYMTestActions			Move files and keep checking the memory usage for each operation.
//! @SYMTestExpectedResults	Test completes without any crash and hence without any memory leak.
//! @SYMTestPriority		High
//! @SYMTestStatus			Implemented
//---------------------------------------------
void TestDEF130678()
{
	test.Next(_L("++TestDEF130678\n"));
	
	_LIT(KFromFile,"C:\\TestDEF130678\\FROM\\from_");
	_LIT(KToFile,"C:\\TestDEF130678\\TO\\");

	TInt run;
	// choose a number that certainly tests all memory allocations.
	// it is used for memory allocation failure simulation.
	TInt maxRun = 50;
	// start OOM loop
	for(run=1; run<=maxRun; ++run)
		{
		TInt err = KErrNone;
		TFileName fromFile, toFile;

		fromFile.Append(KFromFile);
		fromFile.AppendNum(run);
		fromFile.Append(_L(".txt"));
		MakeFile(fromFile);
		
		MakeDir(_L("C:\\TestDEF130678\\FROM\\"));
		MakeDir(_L("C:\\TestDEF130678\\TO\\"));
		toFile.Append(KToFile);
		
		// Check the memory usage
		__UHEAP_MARK;
		// set to fail every run-th memory allocation
		__UHEAP_SETFAIL(RAllocator::EDeterministic, run);

		CFileMan* fileMan = NULL;
		TInt errTrap1 = KErrNone;
		TRAP(errTrap1,(fileMan=CFileMan::NewL(TheFs)));
		if (errTrap1 != KErrNone)
			{
			// reset the memory allocation failure and check for any leak
			__UHEAP_RESET;
			__UHEAP_MARKEND;
			continue;
			}

		CleanupStack::PushL(fileMan);
		TInt errTrap2 = KErrNone;
		TRAP(errTrap2,(err = fileMan->Move(fromFile,toFile)));
		if (errTrap2 != KErrNone || err != KErrNone)
			{
			CleanupStack::PopAndDestroy(fileMan);
			// reset the memory allocation failure and check for any leak
			__UHEAP_RESET;
			__UHEAP_MARKEND;
			continue;
			}
		CleanupStack::PopAndDestroy(fileMan);
		// reset the memory allocation failure and check for any leak
		__UHEAP_RESET;
		__UHEAP_MARKEND;
		} // End of OOM loop
		
	// cleanup
	RmDir(_L("C:\\TestDEF130678\\"));
	test.Next(_L("--TestDEF130678\n"));		
}

GLDEF_C void CallTestsL()
//
// Do tests
//
	{
	// T_FMAN is independent of all tests so format first
#ifndef __WINS__
	Format(CurrentDrive());
#endif

	InitialiseL();
	CreateTestDirectory(_L("\\F32-TST\\TFMAN\\"));
//	May not be able to test handling of invalid path lengths because F32 fix 
//	to prevent paths >256 ever being created
	testingInvalidPathLengths = CheckIfShortPathsAreSupported();
	
	gAsynch=ETrue;
	
	test.Next(_L("Asynchronous tests ..."));
	TheFs.SetAllocFailure(gAllocFailOff);

	TInt uid;
	test(HAL::Get(HAL::EMachineUid,uid)==KErrNone);
	TBool doTargetTests =  (!IsTestingLFFS() && 
							uid!=HAL::EMachineUid_Cogent && 
							uid!=HAL::EMachineUid_IQ80310 && 
							uid!=HAL::EMachineUid_X86PC);

	if (doTargetTests)
		{
		TestMoveAcrossDrives();
		TestRecursiveMoveAcrossDrives();
		TestMoveEmptyDirectory();
		TestAbortedMoveAcrossDrives();
		TestPDEF112148();
		}

	TestOverWrite();
	TestRename();
	TestErrorHandling();

	TestRecursiveMove();
	TestRecursiveDelete();
	TestRecursiveAttribs();
	TestRecursiveCopy();
	
	TestRmDir();
	TestSimultaneous();
	TestAttribs();
	TestDelete();
	if (!IsTestingLFFS())
		TestCopy(); // ???
	TestMove();
	TestCopyAllCancel();

	gAsynch=EFalse;
	test.Next(_L("Synchronous tests ..."));
	TheFs.SetAllocFailure(gAllocFailOn);

	if (doTargetTests)
		{
		TestMoveAcrossDrives();
		TestRecursiveMoveAcrossDrives();
		TestMoveEmptyDirectory();
		TestAbortedMoveAcrossDrives();
		TestPDEF112148();
		}

	TestCopyOpenFile();
	if(testingInvalidPathLengths)
		TestLongNames();
	TestNameMangling();
	TestFileAttributes();
	TestOverWrite();
	TestRename();
	TestErrorHandling();
	TestRecursiveMove();
	TestRecursiveDelete();
	TestRecursiveAttribs();
	TestRecursiveCopy();
	TestRmDir();
	TestSimultaneous();
	TestAttribs();
	TestDelete();
	TestCopy();
	TestMove();
	TestCopyAndRename();
	TestCopyAllCancel();
	
	// OOM testing
	TestDEF130678();
#ifndef __WINS__
	RThread t;
	TThreadStackInfo stack;
	test(t.StackInfo(stack)==KErrNone);
	TestStackUsage(0, stack);
#endif

	Cleanup();
	DeleteTestDirectory();
	test(TheFs.RmDir(_L("\\F32-TST\\")) == KErrNone);
	}