--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_fman.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,4375 @@
+// 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);
+ }
+