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