// 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:

//

#define __E32TEST_EXTENSION__

#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;

LOCAL_D TChar gSecDrive;        // a second drive for inter-drive tests

LOCAL_D TBool gSecDriveReady;

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

//

	{

    (void) MFileManObserver::NotifyFileManEnded();

	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_Equal(KErrAlreadyExists, lastError);

		test_Value(KErrNotFound, 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 TBool GetSecondDrive(TChar& aDrive) // Get the drive that is ready.

    {

    TDriveList list;

    TheFs.DriveList(list);

    if (list[EDriveD] != 0)

        {

        aDrive = 'D';

        return ETrue;

        }

    TInt drv;

    // In minibsp rom(sirocco) there is no D drive

    for(drv = EDriveE; drv < EDriveZ; drv++)

        {

        if (list[drv] != 0) 

            {

            aDrive = 'A' + drv;

            return ETrue;

            }

        }

    aDrive = '?';

    return EFalse;

    }

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_Value(aResult, 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_Equal(aExpectedAsynchReturnStatus, aReturnVal);

		}

	else

		{

		test_Equal(aExpectedSynchReturn, aReturnVal);

		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_Value(r, 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\\");

        (*aDestOtherDrive)[0] = (TText) gSecDrive;

#else

		*aDestOtherDrive = gSessionPath[0] == 'C' ? _L("Y:\\F32-TST\\TFMAN\\dest\\") : _L("C:\\F32-TST\\TFMAN\\dest\\");

#endif

		err = TheFs.MkDirAll(*aDestOtherDrive);

		test_Value(err, err == KErrNone || err == KErrAlreadyExists);

		}

	err = TheFs.MkDirAll(sourceName);

	test_Value(err, err == KErrNone || err == KErrAlreadyExists);

	err = TheFs.MkDirAll(sourceCompare);

	test_Value(err, err == KErrNone || err == KErrAlreadyExists);

	err = TheFs.MkDirAll(destSameDrive);

	test_Value(err, err == KErrNone || err == KErrAlreadyExists);

	if(aCreateFiles)

		{

		err = TheFs.MkDirAll(sourceNameSubDir);

		test_Value(err, err == KErrNone || err == KErrAlreadyExists);

		err = TheFs.MkDirAll(sourceCompareSubDir);

		test_Value(err, 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_Value(err, 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_Value(err, 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_KErrNone(err);

  		ret = ETrue;

		}

	RmDir(_L("\\longname1\\"));

	return ret;

	}

LOCAL_C void TestDelete()

//

// Test files are deleted

//

	{

	test.Next(_L("Test delete - 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_KErrNone(r);

	//	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_Equal(KErrBadName, r);

		// Testing invalid long path (i.e. >256)

		r=gFileMan->Rename(_L("\\TEST\\LONG"),KInvalidLongPath,CFileMan::EOverWrite);

		test_Equal(KErrBadName, r);

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

		test_KErrNone(r);

		}

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

			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"));	

			test_KErrNone(r);

			}

		}

	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_KErrNone(r);

			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"),0,gStat);	

			WaitForSuccess();

			test_KErrNone(r);

			}

		}

	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_KErrNone(r);

		}

	/**

	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_KErrNone(r);

    TFSName f;

	r = TheFs.FileSystemName(f, theDrive);

	test_Value(r, r == KErrNone || r == KErrNotFound);

    if (f.FindF(_L("Fat")) == 0 )

    	{

		test.Next(_L("Test wild card matching in short file names"));

    	MakeFile(_L("abcdefghi.txt"));

    	TInt err = gFileMan->Delete(_L("ABCDEF~*"));

    	test_KErrNone(err);

    	MakeFile(_L("abcdefghi.txt"));

    	err = gFileMan->Delete(_L("ABCDEF~*.TXT"));

    	test_KErrNone(err);

    	MakeFile(_L("abcdefghi.txt"));

    	err = gFileMan->Delete(_L("ABCDEF~*.?XT"));

    	test_KErrNone(err);

    	MakeFile(_L("abcdefghi.txt"));

    	err = gFileMan->Delete(_L("ABCDEF~1.*"));

    	test_KErrNone(err);

    	}

	}

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 than 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_KErrNone(r);

		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