Mercurial Mercurial > oss > FCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/f32test/server/t_dirs.cpp
changeset 109 b3a1d9898418
parent 0 a41df078684a
child 257 3e88ff8f41d5
equal deleted inserted replaced
102:ef2a444a7410 109:b3a1d9898418 
    13 // Description:
 
    13 // Description:
 
    14 // f32test\server\t_dirs.cpp
 
    14 // f32test\server\t_dirs.cpp
 
    15 // 
    15 // 
    16 //
 
    16 //
 
    17 
    17 
       
    18 #define __E32TEST_EXTENSION__
 
    18 #include <f32file.h>
 
    19 #include <f32file.h>
 
    19 #include <e32test.h>
 
    20 #include <e32test.h>
 
    20 #include "t_server.h"
 
    21 #include "t_server.h"
 
    21 
    22 
    22 #include "f32_test_utils.h"
 
    23 #include "f32_test_utils.h"
 
    39 	RFile f;
 
    40 	RFile f;
 
    40 	TInt maxEntry=56;
 
    41 	TInt maxEntry=56;
 
    41 	test.Next(_L("Create a directory with 55 entries"));
 
    42 	test.Next(_L("Create a directory with 55 entries"));
 
    42 	TFileName sessionPath;
 
    43 	TFileName sessionPath;
 
    43 	TInt r=TheFs.SessionPath(sessionPath);
 
    44 	TInt r=TheFs.SessionPath(sessionPath);
 
    44 	test(r==KErrNone);
 
    45 	test_KErrNone(r);
 
    45 	r=TheFs.MkDir(_L("\\F32-TST\\"));
 
    46 	r=TheFs.MkDir(_L("\\F32-TST\\"));
 
    46 	test((r==KErrNone)||(r==KErrAlreadyExists));
 
    47 	test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));
 
    47 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\"));
 
    48 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\"));
 
    48 	test((r==KErrNone)||(r==KErrAlreadyExists));
 
    49 	test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));
 
    49 	
    50 	
    50 	for (TInt i=0;i<maxEntry;i++)
 
    51 	for (TInt i=0;i<maxEntry;i++)
 
    51 		{
 
    52 		{
 
    52 		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
 
    53 		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
 
    53 		baseName.AppendNum(i);
 
    54 		baseName.AppendNum(i);
 
    54 		r=f.Replace(TheFs,baseName,EFileRead);
 
    55 		r=f.Replace(TheFs,baseName,EFileRead);
 
    55 		test(r==KErrNone);
 
    56 		test_KErrNone(r);
 
    56 		r=f.Write(_L8("Hello World"));
 
    57 		r=f.Write(_L8("Hello World"));
 
    57 		test(r==KErrNone);
 
    58 		test_KErrNone(r);
 
    58 		f.Close();
 
    59 		f.Close();
 
    59 		}
 
    60 		}
 
    60 	test.Next(_L("Test all entries have been created successfully."));
 
    61 	test.Next(_L("Test all entries have been created successfully."));
 
    61 	for (TInt j=0;j<=maxEntry;j++)
 
    62 	for (TInt j=0;j<=maxEntry;j++)
 
    62 		{
 
    63 		{
 
    63 		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
 
    64 		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");
 
    64 		baseName.AppendNum(j);
 
    65 		baseName.AppendNum(j);
 
    65 		TInt r=f.Open(TheFs,baseName,EFileRead);
 
    66 		TInt r=f.Open(TheFs,baseName,EFileRead);
 
    66 		if (r!=KErrNone)
 
    67 		if (r!=KErrNone)
 
    67 			{
 
    68 			{
 
    68 			test(r==KErrNotFound && j==maxEntry);
 
    69 			test_Value(r, r == KErrNotFound && j==maxEntry);
 
    69 			return;
 
    70 			return;
 
    70 			}
 
    71 			}
 
    71 		TBuf8<16> data;
 
    72 		TBuf8<16> data;
 
    72 		r=f.Read(data);
 
    73 		r=f.Read(data);
 
    73 		test(r==KErrNone);
 
    74 		test_KErrNone(r);
 
    74 		test(data==_L8("Hello World"));
 
    75 		test(data==_L8("Hello World"));
 
    75 		f.Close();
 
    76 		f.Close();
 
    76 		}
 
    77 		}
 
    77 	}
 
    78 	}
 
    78 	
    79 	
   113 	test.Next(_L("Open files and directories on Z:"));
 
   114 	test.Next(_L("Open files and directories on Z:"));
 
   114 	TEntry entry;
 
   115 	TEntry entry;
 
   115 	RDir d;
 
   116 	RDir d;
 
   116 	
   117 	
   117 	TInt r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE\\*"):_L("\\System\\Bin\\ESHELL.EXE\\*"),KEntryAttMaskSupported);
 
   118 	TInt r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE\\*"):_L("\\System\\Bin\\ESHELL.EXE\\*"),KEntryAttMaskSupported);
 
   118 	test(r==KErrPathNotFound);
 
   119 	test_Value(r, r == KErrPathNotFound);
 
   119 	
   120 	
   120 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE"):_L("\\System\\Bin\\ESHELL.EXE"),KEntryAttMaskSupported);
 
   121 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE"):_L("\\System\\Bin\\ESHELL.EXE"),KEntryAttMaskSupported);
 
   121 	test(r==KErrNone);
 
   122 	test_KErrNone(r);
 
   122 	
   123 	
   123 	r=d.Read(entry);
 
   124 	r=d.Read(entry);
 
   124 	if (r==KErrEof)
 
   125 	if (r==KErrEof)
 
   125 		{
 
   126 		{
 
   126 		test.Printf(_L("Error: EShell.EXE not found\n"));
 
   127 		test.Printf(_L("Error: EShell.EXE not found\n"));
 
   127 		//test.Getch();
 
   128 		//test.Getch();
 
   128 		}
 
   129 		}
 
   129 	else
 
   130 	else
 
   130 		{
 
   131 		{
 
   131 		test(r==KErrNone);
 
   132 		test_KErrNone(r);
 
   132 		test(entry.iName.FindF(_L("ESHELL.EXE"))>=0);
 
   133 		test(entry.iName.FindF(_L("ESHELL.EXE"))>=0);
 
   133 		r=d.Read(entry);
 
   134 		r=d.Read(entry);
 
   134 		test(r==KErrEof);
 
   135 		test_Value(r, r == KErrEof);
 
   135 		}
 
   136 		}
 
   136 	d.Close();
 
   137 	d.Close();
 
   137 
   138 
   138 	r=d.Open(TheFs,_L("\\*.XQP"),KEntryAttMaskSupported);
 
   139 	r=d.Open(TheFs,_L("\\*.XQP"),KEntryAttMaskSupported);
 
   139 	test(r==KErrNone);
 
   140 	test_KErrNone(r);
 
   140 	r=d.Read(entry);
 
   141 	r=d.Read(entry);
 
   141 	test(r==KErrEof);
 
   142 	test_Value(r, r == KErrEof);
 
   142 	d.Close();
 
   143 	d.Close();
 
   143 
   144 
   144 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\"):_L("\\System\\Bin\\"),KEntryAttMaskSupported);
 
   145 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\"):_L("\\System\\Bin\\"),KEntryAttMaskSupported);
 
   145 	test(r==KErrNone);
 
   146 	test_KErrNone(r);
 
   146 	r=d.Read(entry);
 
   147 	r=d.Read(entry);
 
   147 	
   148 	
   148 	if (r==KErrEof)
 
   149 	if (r==KErrEof)
 
   149 		{
 
   150 		{
 
   150 		test.Printf(_L("No files found\n"));
 
   151 		test.Printf(_L("No files found\n"));
 
   151 		d.Close();
 
   152 		d.Close();
 
   152 		}
 
   153 		}
 
   153 	else
 
   154 	else
 
   154 		{
 
   155 		{
 
   155 		test(r==KErrNone);
 
   156 		test_KErrNone(r);
 
   156 		test.Printf(_L("First Entry = %S\n"),&entry.iName);
 
   157 		test.Printf(_L("First Entry = %S\n"),&entry.iName);
 
   157 		r=d.Read(entry);
 
   158 		r=d.Read(entry);
 
   158 		test(r==KErrNone);
 
   159 		test_KErrNone(r);
 
   159 		test.Printf(_L("Second Entry = %S\n"),&entry.iName);
 
   160 		test.Printf(_L("Second Entry = %S\n"),&entry.iName);
 
   160 		d.Close();
 
   161 		d.Close();
 
   161 		}
 
   162 		}
 
   162 
   163 
   163 	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
 
   164 	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
 
   164 	test(r==KErrNone);
 
   165 	test_KErrNone(r);
 
   165 	d.Close();
 
   166 	d.Close();
 
   166 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\*"):_L("\\System\\Bin\\*"),KEntryAttMaskSupported);
 
   167 	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\*"):_L("\\System\\Bin\\*"),KEntryAttMaskSupported);
 
   167 	test(r==KErrNone);
 
   168 	test_KErrNone(r);
 
   168 	d.Close();
 
   169 	d.Close();
 
   169 	}
 
   170 	}
 
   170 
   171 
   171 static void Test3()
 
   172 static void Test3()
 
   172 //
 
   173 //
 
   176 
   177 
   177 	test.Next(_L("Open files and directories"));
 
   178 	test.Next(_L("Open files and directories"));
 
   178 	TEntry entry;
 
   179 	TEntry entry;
 
   179 	RFile f;
 
   180 	RFile f;
 
   180 	TInt r=f.Replace(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),EFileWrite);
 
   181 	TInt r=f.Replace(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),EFileWrite);
 
   181 	test(r==KErrNone);
 
   182 	test_KErrNone(r);
 
   182 	r=f.Write(_L8("TESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATA"));
 
   183 	r=f.Write(_L8("TESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATA"));
 
   183 	test(r==KErrNone);
 
   184 	test_KErrNone(r);
 
   184 	r=TheFs.Delete(_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"));
 
   185 	r=TheFs.Delete(_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"));
 
   185 	test(r==KErrInUse);
 
   186 	test_Value(r, r == KErrInUse);
 
   186 	f.Close();
 
   187 	f.Close();
 
   187 	RDir d;
 
   188 	RDir d;
 
   188 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR\\*"),KEntryAttMaskSupported);
 
   189 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR\\*"),KEntryAttMaskSupported);
 
   189 	test(r==KErrPathNotFound);
 
   190 	test_Value(r, r == KErrPathNotFound);
 
   190 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\*.XQP"),KEntryAttMaskSupported);
 
   191 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\*.XQP"),KEntryAttMaskSupported);
 
   191 	test(r==KErrNone);
 
   192 	test_KErrNone(r);
 
   192 	r=d.Read(entry);
 
   193 	r=d.Read(entry);
 
   193 	test(r==KErrEof);
 
   194 	test_Value(r, r == KErrEof);
 
   194 	d.Close();
 
   195 	d.Close();
 
   195 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),KEntryAttMaskSupported);
 
   196 	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),KEntryAttMaskSupported);
 
   196 	test(r==KErrNone);
 
   197 	test_KErrNone(r);
 
   197 	r=d.Read(entry);
 
   198 	r=d.Read(entry);
 
   198 	test(r==KErrNone);
 
   199 	test_KErrNone(r);
 
   199 	test(entry.iName.FindF(_L("TESTFILEORISITA.DIR"))>=0);
 
   200 	test(entry.iName.FindF(_L("TESTFILEORISITA.DIR"))>=0);
 
   200 	r=d.Read(entry);
 
   201 	r=d.Read(entry);
 
   201 	test(r==KErrEof);
 
   202 	test_Value(r, r == KErrEof);
 
   202 	d.Close();
 
   203 	d.Close();
 
   203 	r=d.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
 
   204 	r=d.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
 
   204 	test(r==KErrNone);
 
   205 	test_KErrNone(r);
 
   205 	d.Close();
 
   206 	d.Close();
 
   206 	r=d.Open(TheFs,_L("\\F32-TST\\"),KEntryAttMaskSupported);
 
   207 	r=d.Open(TheFs,_L("\\F32-TST\\"),KEntryAttMaskSupported);
 
   207 	test(r==KErrNone);
 
   208 	test_KErrNone(r);
 
   208 	d.Close();
 
   209 	d.Close();
 
   209 	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
 
   210 	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);
 
   210 	test(r==KErrNone);
 
   211 	test_KErrNone(r);
 
   211 	d.Close();
 
   212 	d.Close();
 
   212 	r=d.Open(TheFs,_L("\\F32-TST\\*"),KEntryAttMaskSupported);
 
   213 	r=d.Open(TheFs,_L("\\F32-TST\\*"),KEntryAttMaskSupported);
 
   213 	test(r==KErrNone);
 
   214 	test_KErrNone(r);
 
   214 	d.Close();
 
   215 	d.Close();
 
   215 	
   216 	
   216 	// create a small file on the root
 
   217 	// create a small file on the root
 
   217 	test(f.Replace(TheFs, _L("\\TEST.FILE"), EFileWrite) == KErrNone);
 
   218 	test(f.Replace(TheFs, _L("\\TEST.FILE"), EFileWrite) == KErrNone);
 
   218 	test(f.Write(_L8("1234567890987654321234567890")) == KErrNone);
 
   219 	test(f.Write(_L8("1234567890987654321234567890")) == KErrNone);
 
   224 	// cleanup
 
   225 	// cleanup
 
   225 	TheFs.Delete(_L("\\TEST.FILE"));	
   226 	TheFs.Delete(_L("\\TEST.FILE"));	
   226 	
   227 	
   227 	
   228 	
   228 	r=TheFs.MkDir(_L("\\F32-TST\\EMPTY\\"));
 
   229 	r=TheFs.MkDir(_L("\\F32-TST\\EMPTY\\"));
 
   229 	test(r==KErrNone || r==KErrAlreadyExists);
 
   230 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   230 	r=d.Open(TheFs,_L("\\F32-TST\\EMPTY\\*"),KEntryAttMaskSupported);
 
   231 	r=d.Open(TheFs,_L("\\F32-TST\\EMPTY\\*"),KEntryAttMaskSupported);
 
   231 	test(r==KErrNone);
 
   232 	test_KErrNone(r);
 
   232 //	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   233 //	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   233 	r=d.Read(entry);
 
   234 	r=d.Read(entry);
 
   234 	test(r==KErrEof);
 
   235 	test_Value(r, r == KErrEof);
 
   235 //	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   236 //	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   236 //	test(r==KErrInUse);
 
   237 //	test_Value(r, r == KErrInUse);
 
   237 	r=d.Read(entry);
 
   238 	r=d.Read(entry);
 
   238 	r=d.Read(entry);
 
   239 	r=d.Read(entry);
 
   239 	r=d.Read(entry);
 
   240 	r=d.Read(entry);
 
   240 	d.Close();
 
   241 	d.Close();
 
   241 	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   242 	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));
 
   242 	test(r==KErrNone);
 
   243 	test_KErrNone(r);
 
   243 	}
 
   244 	}
 
   244 
   245 
   245 
   246 
   246 static void CreateSortNoneTestDirectoryStructure()
 
   247 static void CreateSortNoneTestDirectoryStructure()
 
   247 //
 
   248 //
 
   254 //	the time this function was run...
 
   255 //	the time this function was run...
 
   255 	
   256 	
   256 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   257 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   257 	test(fMan!=NULL);
 
   258 	test(fMan!=NULL);
 
   258 	TInt r=fMan->RmDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
 
   259 	TInt r=fMan->RmDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
 
   259 	test((r==KErrNone)||(r==KErrPathNotFound));
 
   260 	test_Value(r, (r == KErrNone)||(r==KErrPathNotFound));
 
   260 	delete fMan;	
   261 	delete fMan;	
   261 
   262 
   262 	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
 
   263 	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
 
   263 	r=TheFs.MkDirAll(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
 
   264 	r=TheFs.MkDirAll(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));
 
   264 	test(r==KErrNone || r==KErrAlreadyExists);
 
   265 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   265 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.txt"));
 
   266 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.txt"));
 
   266 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR1.APP\\"));
 
   267 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR1.APP\\"));
 
   267 	test(r==KErrNone || r==KErrAlreadyExists);
 
   268 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   268 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.app"));
 
   269 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.app"));
 
   269 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR2.TXT\\"));
 
   270 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR2.TXT\\"));
 
   270 	test(r==KErrNone || r==KErrAlreadyExists);
 
   271 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   271 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.txt"));
 
   272 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.txt"));
 
   272 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR3.APP\\"));
 
   273 	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR3.APP\\"));
 
   273 	test(r==KErrNone || r==KErrAlreadyExists);
 
   274 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   274 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\ZZZZ"));
 
   275 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\ZZZZ"));
 
   275 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\AAAA"));
 
   276 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\AAAA"));
 
   276 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\WWWW"));
 
   277 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\WWWW"));
 
   277 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.app"));
 
   278 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.app"));
 
   278 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.txt"));
 
   279 	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.txt"));
 
   297 // GetDir OOM failure passes 'callback' test from client side but not server side
 
   298 // GetDir OOM failure passes 'callback' test from client side but not server side
 
   298 //
 
   299 //
 
   299 	TheFs.SetAllocFailure(gAllocFailOff);
 
   300 	TheFs.SetAllocFailure(gAllocFailOff);
 
   300 
   301 
   301 	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortNone,dir);
 
   302 	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortNone,dir);
 
   302 	test(r==KErrNone);
 
   303 	test_KErrNone(r);
 
   303 	TInt count=dir->Count();
 
   304 	TInt count=dir->Count();
 
   304 	test(count==15);
 
   305 	test(count==15);
 
   305 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortByName,dirSorted);
 
   306 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortByName,dirSorted);
 
   306 	test(r==KErrNone);
 
   307 	test_KErrNone(r);
 
   307 	test(dirSorted->Count()==15);
 
   308 	test(dirSorted->Count()==15);
 
   308 	delete dirSorted;
 
   309 	delete dirSorted;
 
   309 	delete dir;
 
   310 	delete dir;
 
   310 
   311 
   311 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.txt"),KEntryAttNormal,ESortNone,dir);
 
   312 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.txt"),KEntryAttNormal,ESortNone,dir);
 
   312 	test(r==KErrNone);
 
   313 	test_KErrNone(r);
 
   313 	test(dir->Count()==3);
 
   314 	test(dir->Count()==3);
 
   314 	delete dir;
 
   315 	delete dir;
 
   315 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal,ESortNone,dir);
 
   316 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal,ESortNone,dir);
 
   316 	test(r==KErrNone);
 
   317 	test_KErrNone(r);
 
   317 	test(dir->Count()==3);
 
   318 	test(dir->Count()==3);
 
   318 	delete dir;
 
   319 	delete dir;
 
   319 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone,dir);
 
   320 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone,dir);
 
   320 	test(r==KErrNone);
 
   321 	test_KErrNone(r);
 
   321 	test(dir->Count()==5);
 
   322 	test(dir->Count()==5);
 
   322 	delete dir;
 
   323 	delete dir;
 
   323 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsFirst,dir);
 
   324 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsFirst,dir);
 
   324 	test(r==KErrNone);
 
   325 	test_KErrNone(r);
 
   325 	test(dir->Count()==5);
 
   326 	test(dir->Count()==5);
 
   326 	delete dir;
 
   327 	delete dir;
 
   327 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsLast,dir);
 
   328 	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsLast,dir);
 
   328 	test(r==KErrNone);
 
   329 	test_KErrNone(r);
 
   329 	test(dir->Count()==5);
 
   330 	test(dir->Count()==5);
 
   330 	delete dir;
 
   331 	delete dir;
 
   331 
   332 
   332 	TheFs.SetAllocFailure(gAllocFailOn);
 
   333 	TheFs.SetAllocFailure(gAllocFailOn);
 
   333 	}
 
   334 	}
 
   339 	{
 
   340 	{
 
   340 
   341 
   341 	test.Next(_L("Test return values"));
 
   342 	test.Next(_L("Test return values"));
 
   342 	RDir dir;
 
   343 	RDir dir;
 
   343 	TInt r=dir.Open(TheFs,_L("\\DoesNotExist\\*"),KEntryAttMaskSupported);
 
   344 	TInt r=dir.Open(TheFs,_L("\\DoesNotExist\\*"),KEntryAttMaskSupported);
 
   344 	test(r==KErrPathNotFound);
 
   345 	test_Value(r, r == KErrPathNotFound);
 
   345 	r=dir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
 
   346 	r=dir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
 
   346 	test(r==KErrNone);
 
   347 	test_KErrNone(r);
 
   347 	dir.Close();
 
   348 	dir.Close();
 
   348 	}
 
   349 	}
 
   349 
   350 
   350 
   351 
   351 static void Test6()
 
   352 static void Test6()
 
   355 	{
 
   356 	{
 
   356 
   357 
   357 	test.Next(_L("Test *.* matches all files"));
 
   358 	test.Next(_L("Test *.* matches all files"));
 
   358 	CDir* dirList;
 
   359 	CDir* dirList;
 
   359 	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir,ESortByName|EDirsLast,dirList);
 
   360 	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir,ESortByName|EDirsLast,dirList);
 
   360 	test(r==KErrNone);
 
   361 	test_KErrNone(r);
 
   361 	TInt count=dirList->Count();
 
   362 	TInt count=dirList->Count();
 
   362 	test(count==15);
 
   363 	test(count==15);
 
   363 	TEntry entry=(*dirList)[0];
 
   364 	TEntry entry=(*dirList)[0];
 
   364 	test(entry.iName.FindF(_L("AAAA"))>=0);
 
   365 	test(entry.iName.FindF(_L("AAAA"))>=0);
 
   365 	entry=(*dirList)[1];
 
   366 	entry=(*dirList)[1];
 
   392 	test(entry.iName.FindF(_L("FILE_DIR3.APP"))>=0);
 
   393 	test(entry.iName.FindF(_L("FILE_DIR3.APP"))>=0);
 
   393 	delete dirList;
 
   394 	delete dirList;
 
   394 
   395 
   395 	RDir dir;
 
   396 	RDir dir;
 
   396 	r=dir.Open(TheFs,_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir);
 
   397 	r=dir.Open(TheFs,_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir);
 
   397 	test(r==KErrNone);
 
   398 	test_KErrNone(r);
 
   398 	
   399 	
   399 	TTime time;
 
   400 	TTime time;
 
   400 	TInt64 difference;
 
   401 	TInt64 difference;
 
   401 	TInt64 maxOK=1000000;
 
   402 	TInt64 maxOK=1000000;
 
   402 	maxOK*=60;
 
   403 	maxOK*=60;
 
   403 	maxOK*=3;
 
   404 	maxOK*=3;
 
   404 
   405 
   405 	for (TInt i=0; i<15; i++)
 
   406 	for (TInt i=0; i<15; i++)
 
   406 		{
 
   407 		{
 
   407 		r=dir.Read(entry);
 
   408 		r=dir.Read(entry);
 
   408 		test(r==KErrNone);
 
   409 		test_KErrNone(r);
 
   409 		time=entry.iModified;
 
   410 		time=entry.iModified;
 
   410 		difference=time.Int64()-gTimeNow.Int64();
 
   411 		difference=time.Int64()-gTimeNow.Int64();
 
   411 		test(difference<maxOK);
 
   412 		test(difference<maxOK);
 
   412 		}
 
   413 		}
 
   413 
   414 
   414 	r=dir.Read(entry);
 
   415 	r=dir.Read(entry);
 
   415 	test(r==KErrEof);
 
   416 	test_Value(r, r == KErrEof);
 
   416 	dir.Close();
 
   417 	dir.Close();
 
   417 
   418 
   418 	TheFs.SetAllocFailure(gAllocFailOn);
 
   419 	TheFs.SetAllocFailure(gAllocFailOn);
 
   419 	}
 
   420 	}
 
   420 
   421 
   431         test.Printf(_L("Skipping. Applicable for FAT12/16 only!\n"));
 
   432         test.Printf(_L("Skipping. Applicable for FAT12/16 only!\n"));
 
   432         return;
 
   433         return;
 
   433         }    
   434         }    
   434 
   435 
   435     TInt r = FormatDrive(TheFs, gDriveNum, ETrue);
 
   436     TInt r = FormatDrive(TheFs, gDriveNum, ETrue);
 
   436     test(r==KErrNone);
 
   437     test_KErrNone(r);
 
   437 
   438 
   438 	TBuf<32> baseName=_L("\\RD");
 
   439 	TBuf<32> baseName=_L("\\RD");
 
   439 	TBuf<32> id;
 
   440 	TBuf<32> id;
 
   440 	TBuf<32> fileName;
 
   441 	TBuf<32> fileName;
 
   441 	TInt count=0;
 
   442 	TInt count=0;
 
   451 		TInt r=f.Replace(TheFs,fileName,EFileWrite);
 
   452 		TInt r=f.Replace(TheFs,fileName,EFileWrite);
 
   452 		if(r==KErrDirFull)
 
   453 		if(r==KErrDirFull)
 
   453 			{
 
   454 			{
 
   454 			break;
 
   455 			break;
 
   455 			}
 
   456 			}
 
   456 		test(r==KErrNone);
 
   457 		test_KErrNone(r);
 
   457 		f.Close();
 
   458 		f.Close();
 
   458 		count++;
 
   459 		count++;
 
   459 		if(count >= 1000)
 
   460 		if(count >= 1000)
 
   460 			{
 
   461 			{
 
   461 			break;
 
   462 			break;
 
   469 		id.Num(count);
 
   470 		id.Num(count);
 
   470 		fileName=parser.Drive();
 
   471 		fileName=parser.Drive();
 
   471 		fileName+=baseName;
 
   472 		fileName+=baseName;
 
   472 		fileName+=id;
 
   473 		fileName+=id;
 
   473 		TInt r=TheFs.Delete(fileName);
 
   474 		TInt r=TheFs.Delete(fileName);
 
   474 		test(r==KErrNone);
 
   475 		test_KErrNone(r);
 
   475 		test.Printf(_L("DeleteFile	:	%d	: %S\r"),count,&fileName);
 
   476 		test.Printf(_L("DeleteFile	:	%d	: %S\r"),count,&fileName);
 
   476 		--count;
 
   477 		--count;
 
   477 		}
 
   478 		}
 
   478 	test.Printf(_L("\n"));
 
   479 	test.Printf(_L("\n"));
 
   479 
   480 
   483 //	Mem::Fill((TUint8*)longFileName.Ptr(),254,'A');
 
   484 //	Mem::Fill((TUint8*)longFileName.Ptr(),254,'A');
 
   484 	Mem::Fill((TUint8*)longFileName.Ptr(),254*sizeof(TText),'A');
 
   485 	Mem::Fill((TUint8*)longFileName.Ptr(),254*sizeof(TText),'A');
 
   485 	longFileName[0]='\\';
 
   486 	longFileName[0]='\\';
 
   486 	longFileName[253]='\\';
 
   487 	longFileName[253]='\\';
 
   487 	r=TheFs.MkDir(longFileName);
 
   488 	r=TheFs.MkDir(longFileName);
 
   488 	test(r==KErrNone);
 
   489 	test_KErrNone(r);
 
   489 	CDir* dirList=NULL;
 
   490 	CDir* dirList=NULL;
 
   490 	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
 
   491 	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
 
   491 	test(r==KErrNone);
 
   492 	test_KErrNone(r);
 
   492 	count=dirList->Count();
 
   493 	count=dirList->Count();
 
   493 	test(count==0);
 
   494 	test(count==0);
 
   494 	delete dirList;
 
   495 	delete dirList;
 
   495 	TParse parse;
 
   496 	TParse parse;
 
   496 	r=TheFs.Parse(longFileName,parse);
 
   497 	r=TheFs.Parse(longFileName,parse);
 
   497 	test(r==KErrNone);
 
   498 	test_KErrNone(r);
 
   498 	TEntry entry;
 
   499 	TEntry entry;
 
   499 	r=TheFs.Entry(longFileName,entry);
 
   500 	r=TheFs.Entry(longFileName,entry);
 
   500 	test(r==KErrNone);
 
   501 	test_KErrNone(r);
 
   501 	r=TheFs.SetSessionPath(longFileName);
 
   502 	r=TheFs.SetSessionPath(longFileName);
 
   502 	test(r==KErrNone);
 
   503 	test_KErrNone(r);
 
   503 	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
 
   504 	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);
 
   504 	test(r==KErrNone);
 
   505 	test_KErrNone(r);
 
   505 	count=dirList->Count();
 
   506 	count=dirList->Count();
 
   506 	test(count==0);
 
   507 	test(count==0);
 
   507 	delete dirList;
 
   508 	delete dirList;
 
   508 	r=TheFs.Parse(longFileName,_L("*"),parse);
 
   509 	r=TheFs.Parse(longFileName,_L("*"),parse);
 
   509 	test(r==KErrBadName);
 
   510 	test_Value(r, r == KErrBadName);
 
   510 	r=f.Open(TheFs,_L("asdf.asdf"),0);
 
   511 	r=f.Open(TheFs,_L("asdf.asdf"),0);
 
   511 	test(r==KErrBadName);
 
   512 	test_Value(r, r == KErrBadName);
 
   512 	r=TheFs.Entry(longFileName,entry);
 
   513 	r=TheFs.Entry(longFileName,entry);
 
   513 	test(r==KErrNone);
 
   514 	test_KErrNone(r);
 
   514 	r=TheFs.RmDir(longFileName);
 
   515 	r=TheFs.RmDir(longFileName);
 
   515 	test(r==KErrNone);
 
   516 	test_KErrNone(r);
 
   516 	}
 
   517 	}
 
   517 
   518 
   518 static void Test8()
 
   519 static void Test8()
 
   519 //
 
   520 //
 
   520 // Regression tests
 
   521 // Regression tests
 
   523 
   524 
   524 	test.Next(_L("Open dir and change drives"));
 
   525 	test.Next(_L("Open dir and change drives"));
 
   525 	MakeDir(_L("C:\\MOON\\"));
 
   526 	MakeDir(_L("C:\\MOON\\"));
 
   526 	RDir dir;
 
   527 	RDir dir;
 
   527 	TInt r=dir.Open(TheFs,_L("C:\\MOON\\"),0);
 
   528 	TInt r=dir.Open(TheFs,_L("C:\\MOON\\"),0);
 
   528 	test(r==KErrNone);
 
   529 	test_KErrNone(r);
 
   529 	TFileName driveName;
 
   530 	TFileName driveName;
 
   530 	r=TheFs.GetDriveName(11,driveName);
 
   531 	r=TheFs.GetDriveName(11,driveName);
 
   531 	test(r==KErrNone);
 
   532 	test_KErrNone(r);
 
   532 	TEntryArray entryArray;
 
   533 	TEntryArray entryArray;
 
   533 	r=dir.Read(entryArray);
 
   534 	r=dir.Read(entryArray);
 
   534 	test(r==KErrEof);
 
   535 	test_Value(r, r == KErrEof);
 
   535 	test(entryArray.Count()==0);
 
   536 	test(entryArray.Count()==0);
 
   536 	dir.Close();
 
   537 	dir.Close();
 
   537 	r=TheFs.RmDir(_L("C:\\MOON\\"));
 
   538 	r=TheFs.RmDir(_L("C:\\MOON\\"));
 
   538 	test(r==KErrNone);
 
   539 	test_KErrNone(r);
 
   539 
   540 
   540 	test.Next(_L("MkDir all on nonexistent drive"));
 
   541 	test.Next(_L("MkDir all on nonexistent drive"));
 
   541 	r=TheFs.MkDirAll(_L("L:\\MOON"));
 
   542 	r=TheFs.MkDirAll(_L("L:\\MOON"));
 
   542 	test((r==KErrNotReady)||(r==KErrPathNotFound));
 
   543 	test_Value(r, (r == KErrNotReady)||(r==KErrPathNotFound));
 
   543 	}
 
   544 	}
 
   544 
   545 
   545 static void CleanupL()
 
   546 static void CleanupL()
 
   546 //
 
   547 //
 
   547 // Clean up tests
 
   548 // Clean up tests
 
   549 	{
 
   550 	{
 
   550 
   551 
   551 	test.Next(_L("Delete test directory"));
 
   552 	test.Next(_L("Delete test directory"));
 
   552 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   553 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   553 	TInt r=fMan->RmDir(gSessionPath);
 
   554 	TInt r=fMan->RmDir(gSessionPath);
 
   554 	test(r==KErrNone);
 
   555 	test_KErrNone(r);
 
   555 	r=fMan->Delete(_L("\\Filluptherootdir*"));
 
   556 	r=fMan->Delete(_L("\\Filluptherootdir*"));
 
   556 	test(r==KErrNone || r==KErrNotFound);
 
   557 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   557 	delete fMan;
 
   558 	delete fMan;
 
   558 	}
 
   559 	}
 
   559 
   560 
   560 static void Test9()
 
   561 static void Test9()
 
   561 //
 
   562 //
 
   564 	{
 
   565 	{
 
   565 
   566 
   566 	test.Next(_L("Testing directory names with trailing dots"));
 
   567 	test.Next(_L("Testing directory names with trailing dots"));
 
   567 	TInt r;
 
   568 	TInt r;
 
   568 	r=TheFs.MkDir(_L("\\test9..\\"));
 
   569 	r=TheFs.MkDir(_L("\\test9..\\"));
 
   569 	test(r==KErrBadName);
 
   570 	test_Value(r, r == KErrBadName);
 
   570 	r=TheFs.MkDir(_L("\\test9\\"));
 
   571 	r=TheFs.MkDir(_L("\\test9\\"));
 
   571 	test((r==KErrNone)||(r==KErrAlreadyExists));
 
   572 	test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));
 
   572 	r=TheFs.Rename(_L("\\test9\\"),_L("\\test9..\\"));
 
   573 	r=TheFs.Rename(_L("\\test9\\"),_L("\\test9..\\"));
 
   573 	test(r==KErrBadName);
 
   574 	test_Value(r, r == KErrBadName);
 
   574 	r= TheFs.RmDir(_L("\\test9\\"));
 
   575 	r= TheFs.RmDir(_L("\\test9\\"));
 
   575 	test((r==KErrNone));
 
   576 	test_KErrNone(r);
 
   576 	r=TheFs.MkDir(_L("\\t.\\"));
 
   577 	r=TheFs.MkDir(_L("\\t.\\"));
 
   577 	test(r==KErrBadName);
 
   578 	test_Value(r, r == KErrBadName);
 
   578 	}
 
   579 	}
 
   579 
   580 
   580 
   581 
   581 //
 
   582 //
 
   582 // Path and File names for sorting by name
 
   583 // Path and File names for sorting by name
 
   603 	{
 
   604 	{
 
   604 	
   605 	
   605 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   606 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   606 	test(fMan!=NULL);
 
   607 	test(fMan!=NULL);
 
   607 	TInt r=fMan->RmDir(aPath);
 
   608 	TInt r=fMan->RmDir(aPath);
 
   608 	test((r==KErrNone)||(r==KErrPathNotFound));
 
   609 	test_Value(r, (r == KErrNone)||(r==KErrPathNotFound));
 
   609 	delete fMan;	
   610 	delete fMan;	
   610 	}
 
   611 	}
 
   611 
   612 
   612 
   613 
   613 static void CreateTestDirectoryStructure(const TDesC& aPath, const TDesC** aFileArray, TInt aNumFiles)
 
   614 static void CreateTestDirectoryStructure(const TDesC& aPath, const TDesC** aFileArray, TInt aNumFiles)
 
   617 	{
 
   618 	{
 
   618 	DeleteTestDirectoryStructure(aPath);	
   619 	DeleteTestDirectoryStructure(aPath);	
   619 
   620 
   620 	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
 
   621 	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests
 
   621 	TInt r=TheFs.MkDirAll(aPath);
 
   622 	TInt r=TheFs.MkDirAll(aPath);
 
   622 	test(r==KErrNone || r==KErrAlreadyExists);
 
   623 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   623 
   624 
   624 	TBuf<128> fileName;
 
   625 	TBuf<128> fileName;
 
   625 	for (TInt i = 0; i < aNumFiles; i++)
 
   626 	for (TInt i = 0; i < aNumFiles; i++)
 
   626 		{
 
   627 		{
 
   627 		fileName = aPath;
 
   628 		fileName = aPath;
 
   643 	test.Next(_L("Test ESortByName"));
 
   644 	test.Next(_L("Test ESortByName"));
 
   644 	CDir* dirList;
 
   645 	CDir* dirList;
 
   645 	TBuf<128> sortSpec(KSortByNamePath);
 
   646 	TBuf<128> sortSpec(KSortByNamePath);
 
   646 	sortSpec.Append(KSortAll);
 
   647 	sortSpec.Append(KSortAll);
 
   647 	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast, dirList);
 
   648 	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast, dirList);
 
   648 	test(r==KErrNone);
 
   649 	test_KErrNone(r);
 
   649 	TInt count=dirList->Count();
 
   650 	TInt count=dirList->Count();
 
   650 	test(count==numFiles);
 
   651 	test(count==numFiles);
 
   651 
   652 
   652 
   653 
   653 	TInt i;
 
   654 	TInt i;
 
   668 
   669 
   669 	test.Next(_L("Test ESortByName (descending)"));
 
   670 	test.Next(_L("Test ESortByName (descending)"));
 
   670 
   671 
   671 
   672 
   672 	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast | EDescending, dirList);
 
   673 	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByName | EDirsLast | EDescending, dirList);
 
   673 	test(r==KErrNone);
 
   674 	test_KErrNone(r);
 
   674 	count=dirList->Count();
 
   675 	count=dirList->Count();
 
   675 	test(count==numFiles);
 
   676 	test(count==numFiles);
 
   676 
   677 
   677 
   678 
   678 	for (i = 0; i < count; i++)
 
   679 	for (i = 0; i < count; i++)
 
   735 
   736 
   736 	CDir* dirList;
 
   737 	CDir* dirList;
 
   737 	TBuf<128> sortSpec(KSortByExtPath);
 
   738 	TBuf<128> sortSpec(KSortByExtPath);
 
   738 	sortSpec.Append(KSortAll);
 
   739 	sortSpec.Append(KSortAll);
 
   739 	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast, dirList);
 
   740 	TInt r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast, dirList);
 
   740 	test(r==KErrNone);
 
   741 	test_KErrNone(r);
 
   741 	TInt count=dirList->Count();
 
   742 	TInt count=dirList->Count();
 
   742 	test(count==numFiles);
 
   743 	test(count==numFiles);
 
   743 
   744 
   744 
   745 
   745 	TInt i;
 
   746 	TInt i;
 
   771 
   772 
   772 
   773 
   773 	test.Next(_L("Test ESortByExt (descending)"));
 
   774 	test.Next(_L("Test ESortByExt (descending)"));
 
   774 
   775 
   775 	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast | EDescending, dirList);
 
   776 	r=TheFs.GetDir(sortSpec, KEntryAttNormal | KEntryAttDir, ESortByExt | EDirsLast | EDescending, dirList);
 
   776 	test(r==KErrNone);
 
   777 	test_KErrNone(r);
 
   777 	count=dirList->Count();
 
   778 	count=dirList->Count();
 
   778 	test(count==numFiles);
 
   779 	test(count==numFiles);
 
   779 
   780 
   780 
   781 
   781 	for (i = 0; i < count; i++)
 
   782 	for (i = 0; i < count; i++)
 
   855 	dirTest4 = _L("\\F32-TST\\TDIRS\\test4. . \\");
 
   856 	dirTest4 = _L("\\F32-TST\\TDIRS\\test4. . \\");
 
   856 	dirTest5 = _L("\\F32-TST\\TDIRS\\test5.\\");
 
   857 	dirTest5 = _L("\\F32-TST\\TDIRS\\test5.\\");
 
   857 	dirTest6 = _L("\\F32-TST\\TDIRS\\test6. .\\");
 
   858 	dirTest6 = _L("\\F32-TST\\TDIRS\\test6. .\\");
 
   858 
   859 
   859     TInt err = TheFs.MkDir(dirTest1);
 
   860     TInt err = TheFs.MkDir(dirTest1);
 
   860     test(err == KErrNone);
 
   861     test_KErrNone(err);
 
   861     err = TheFs.MkDir(dirTest2);
 
   862     err = TheFs.MkDir(dirTest2);
 
   862     test(err == KErrBadName);
 
   863     test_Value(err, err == KErrBadName);
 
   863     err = TheFs.MkDir(dirTest3);
 
   864     err = TheFs.MkDir(dirTest3);
 
   864     test(err == KErrBadName);
 
   865     test_Value(err, err == KErrBadName);
 
   865     err = TheFs.MkDir(dirTest4);
 
   866     err = TheFs.MkDir(dirTest4);
 
   866     test(err == KErrBadName);
 
   867     test_Value(err, err == KErrBadName);
 
   867     err = TheFs.MkDir(dirTest5);
 
   868     err = TheFs.MkDir(dirTest5);
 
   868     test(err == KErrBadName);
 
   869     test_Value(err, err == KErrBadName);
 
   869     err = TheFs.MkDir(dirTest6);
 
   870     err = TheFs.MkDir(dirTest6);
 
   870     test(err == KErrBadName);
 
   871     test_Value(err, err == KErrBadName);
 
   871 
   872 
   872     RDir rdir;
 
   873     RDir rdir;
 
   873     err = rdir.Open(TheFs, dirTest1, 0);
 
   874     err = rdir.Open(TheFs, dirTest1, 0);
 
   874     rdir.Close();
 
   875     rdir.Close();
 
   875     test(err == KErrNone);
 
   876     test_KErrNone(err);
 
   876 
   877 
   877     err = rdir.Open(TheFs, dirTest2, 0);
 
   878     err = rdir.Open(TheFs, dirTest2, 0);
 
   878     rdir.Close();
 
   879     rdir.Close();
 
   879     test(err == KErrBadName);
 
   880     test_Value(err, err == KErrBadName);
 
   880 
   881 
   881     err = rdir.Open(TheFs, dirTest3, 0);
 
   882     err = rdir.Open(TheFs, dirTest3, 0);
 
   882     rdir.Close();
 
   883     rdir.Close();
 
   883     test(err == KErrBadName);
 
   884     test_Value(err, err == KErrBadName);
 
   884 
   885 
   885     err = rdir.Open(TheFs, dirTest4, 0);
 
   886     err = rdir.Open(TheFs, dirTest4, 0);
 
   886     rdir.Close();
 
   887     rdir.Close();
 
   887     test(err == KErrBadName);
 
   888     test_Value(err, err == KErrBadName);
 
   888 
   889 
   889     err = rdir.Open(TheFs, dirTest5, 0);
 
   890     err = rdir.Open(TheFs, dirTest5, 0);
 
   890     rdir.Close();
 
   891     rdir.Close();
 
   891     test(err == KErrBadName);
 
   892     test_Value(err, err == KErrBadName);
 
   892 
   893 
   893     err = rdir.Open(TheFs, dirTest6, 0);
 
   894     err = rdir.Open(TheFs, dirTest6, 0);
 
   894     rdir.Close();
 
   895     rdir.Close();
 
   895     test(err == KErrBadName);
 
   896     test_Value(err, err == KErrBadName);
 
   896 
   897 
   897     err = TheFs.RmDir(dirTest1);
 
   898     err = TheFs.RmDir(dirTest1);
 
   898     test(err == KErrNone);
 
   899     test_KErrNone(err);
 
   899     err = TheFs.RmDir(dirTest2);
 
   900     err = TheFs.RmDir(dirTest2);
 
   900     test(err == KErrBadName);
 
   901     test_Value(err, err == KErrBadName);
 
   901     err = TheFs.RmDir(dirTest3);
 
   902     err = TheFs.RmDir(dirTest3);
 
   902     test(err == KErrBadName);
 
   903     test_Value(err, err == KErrBadName);
 
   903     err = TheFs.RmDir(dirTest4);
 
   904     err = TheFs.RmDir(dirTest4);
 
   904     test(err == KErrBadName);
 
   905     test_Value(err, err == KErrBadName);
 
   905     err = TheFs.RmDir(dirTest5);
 
   906     err = TheFs.RmDir(dirTest5);
 
   906     test(err == KErrBadName);
 
   907     test_Value(err, err == KErrBadName);
 
   907     err = TheFs.RmDir(dirTest6);
 
   908     err = TheFs.RmDir(dirTest6);
 
   908     test(err == KErrBadName);
 
   909     test_Value(err, err == KErrBadName);
 
   909 	}
 
   910 	}
 
   910 
   911 
   911 void CallTestsL()
 
   912 void CallTestsL()
 
   912 //
 
   913 //
 
   913 // Do all tests
 
   914 // Do all tests
 
   916 
   917 
   917     //-- set up console output 
   918     //-- set up console output 
   918     F32_Test_Utils::SetConsole(test.Console()); 
   919     F32_Test_Utils::SetConsole(test.Console()); 
   919     
   920     
   920     TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
 
   921     TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
 
   921     test(nRes==KErrNone);
 
   922     test_KErrNone(nRes);
 
   922     
   923     
   923     PrintDrvInfo(TheFs, gDriveNum);
 
   924     PrintDrvInfo(TheFs, gDriveNum);
 
   924 
   925 
   925 	TurnAllocFailureOff();
 
   926 	TurnAllocFailureOff();
 
   926 	CreateTestDirectory(_L("\\F32-TST\\TDIRS\\"));
 
   927 	CreateTestDirectory(_L("\\F32-TST\\TDIRS\\"));
 
   927 	
   928 	
   928 	if (!gTestedZ)
 
   929 	if (!gTestedZ)
 
   929 		{
 
   930 		{
 
   930 		TInt r=TheFs.SetSessionPath(_L("Z:\\"));
 
   931 		TInt r=TheFs.SetSessionPath(_L("Z:\\"));
 
   931 		test(r==KErrNone);
 
   932 		test_KErrNone(r);
 
   932 		Test2();
 
   933 		Test2();
 
   933 		TestZ();
 
   934 		TestZ();
 
   934 		r=TheFs.SetSessionPath(gSessionPath);
 
   935 		r=TheFs.SetSessionPath(gSessionPath);
 
   935 		test(r==KErrNone);
 
   936 		test_KErrNone(r);
 
   936 		test.Next(_L("Run all other tests from \\F32-TST\\TDIRS\\"));
 
   937 		test.Next(_L("Run all other tests from \\F32-TST\\TDIRS\\"));
 
   937 		gTestedZ=ETrue;
 
   938 		gTestedZ=ETrue;
 
   938 		}
 
   939 		}
 
   939 
   940 
   940 	Test8();
 
   941 	Test8();
FCL/sf/os/kernelhwsrv